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 <eikmenub.h>

    19 #include <akncontext.h>

    20 #include <akntitle.h>

    21 #include <atconfigurationappgui.rsg>

    22 #include <stringloader.h>

    23 #include <aknnotewrappers.h>

    24 #include <s32stor.h> // CDictionaryStore

    25 

    26 #include "atconfigurationappguiappui.h"

    27 #include "atconfigurationappgui.hrh"

    28 #include "atconfigurationappguilistboxview.h"

    29 #include "atconfigurationappguiprocessview.h"

    30 #include "atconfigurationappguisettingitemlistview.h"

    31 #include "atconfigurationappguiapplication.h"

    32 #include "atlog.h"

    33 

    34 #include <aknmessagequerydialog.h>

    35 

    36 // CONSTANTS

    37 const TInt KATDefaultUpdatingInterval = 2000000;

    38 _LIT8( KSubTestId, "ATConfigUiSubTest" );

    39 

    40 // -----------------------------------------------------------------------------

    41 // CATConfigurationAppGuiAppUi::CATConfigurationAppGuiAppUi()

    42 // Construct the CATConfigurationAppGuiAppUi instance

    43 // -----------------------------------------------------------------------------

    44 //

    45 CATConfigurationAppGuiAppUi::CATConfigurationAppGuiAppUi()

    46     {

    47     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::CATConfigurationAppGuiAppUi()" );

    48     }

    49 

    50 // -----------------------------------------------------------------------------

    51 // CATConfigurationAppGuiAppUi::ConstructL()

    52 // Completes the second phase of Symbian object construction.

    53 // -----------------------------------------------------------------------------

    54 //

    55 void CATConfigurationAppGuiAppUi::ConstructL()

    56     {

    57     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::ConstructL()" );

    58     

    59     BaseConstructL( EAknEnableSkin  | 

    60                      EAknEnableMSK ); 

    61     InitializeContainersL();

    62     }

    63 

    64 // -----------------------------------------------------------------------------

    65 // CATConfigurationAppGuiAppUi::~CATConfigurationAppGuiAppUi()

    66 // Destructor.

    67 // -----------------------------------------------------------------------------

    68 //

    69 CATConfigurationAppGuiAppUi::~CATConfigurationAppGuiAppUi()

    70     {

    71     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::~CATConfigurationAppGuiAppUi()" );

    72     

    73     if ( iPeriodicTimer )

    74         {

    75         if ( iPeriodicTimer->IsActive() )

    76             {

    77             iPeriodicTimer->Cancel();

    78             }  

    79         delete iPeriodicTimer;  

    80         }

    81  

    82     iSubTestProcesses.Close();

    83     iStorageServer.Close();

    84     }

    85 

    86 // -----------------------------------------------------------------------------

    87 // CATConfigurationAppGuiAppUi::InitializeContainersL()

    88 // Initializes all the controls.

    89 // -----------------------------------------------------------------------------

    90 //

    91 void CATConfigurationAppGuiAppUi::InitializeContainersL()

    92     {

    93     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::InitializeContainersL()" );

    94     

    95     iPeriodicTimer = CPeriodic::New( CActive::EPriorityLow );

    96         

    97     iATConfigurationAppGuiListBoxView = CATConfigurationAppGuiListBoxView::NewL();

    98     AddViewL( iATConfigurationAppGuiListBoxView );

    99     iATConfigurationAppGuiProcessView = CATConfigurationAppGuiProcessView::NewL();

   100     AddViewL( iATConfigurationAppGuiProcessView );

   101     //iATConfigurationAppGuiSettingItemListView = CATConfigurationAppGuiSettingItemListView::NewL();

   102     //AddViewL( iATConfigurationAppGuiSettingItemListView );

   103     

   104     SetDefaultViewL( *iATConfigurationAppGuiListBoxView );

   105 

   106     TInt error = iStorageServer.Connect();

   107         if ( error != KErrNone )

   108             {

   109             HBufC* noteText;

   110             noteText = StringLoader::LoadLC( R_CANT_CONNECT_SERVER );

   111             CAknErrorNote* note = new (ELeave) CAknErrorNote( ETrue );

   112             note->ExecuteLD( *noteText );

   113             CleanupStack::PopAndDestroy( noteText );

   114             }

   115     // Load application settings

   116     //LoadSettingsL();

   117     // Start updating the view

   118     if ( iPeriodicTimer )

   119         {

   120         StartTimerL();    

   121         }    

   122     }

   123 

   124 // -----------------------------------------------------------------------------

   125 // CATConfigurationAppGuiAppUi::HandleCommandL()

   126 // Handle a command for this appui.

   127 // -----------------------------------------------------------------------------

   128 //

   129 void CATConfigurationAppGuiAppUi::HandleCommandL( TInt aCommand )

   130     {

   131     LOGSTR2( "ATCU CATConfigurationAppGuiAppUi::HandleCommandL(%i)", 

   132 			aCommand );

   133     

   134     TBool commandHandled = EFalse;

   135     switch ( aCommand )

   136         { // Code to dispatch to the AppUi's menu and CBA commands is generated here

   137         default:

   138             break;

   139         }

   140 

   141     if ( !commandHandled ) 

   142         {

   143         if ( aCommand == EAknSoftkeyExit || aCommand == EEikCmdExit )

   144             {

   145             // Stop all subtests before closing handles

   146             StopAllSubtestsL();

   147             Exit();

   148             }

   149         }

   150     }

   151 

   152 // -----------------------------------------------------------------------------

   153 // CATConfigurationAppGuiAppUi::HandleResourceChangeL()

   154 // Override of the HandleResourceChangeL virtual function.

   155 // -----------------------------------------------------------------------------

   156 //

   157 void CATConfigurationAppGuiAppUi::HandleResourceChangeL( TInt aType )

   158     {

   159     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::HandleResourceChangeL()" );

   160     

   161     CAknViewAppUi::HandleResourceChangeL( aType );

   162     }

   163 

   164 // -----------------------------------------------------------------------------

   165 // CATConfigurationAppGuiAppUi::HandleKeyEventL()

   166 // Override of the HandleKeyEventL virtual function.

   167 // -----------------------------------------------------------------------------

   168 //

   169 TKeyResponse CATConfigurationAppGuiAppUi::HandleKeyEventL(

   170         const TKeyEvent& /*aKeyEvent*/,

   171         TEventCode /*aType*/ )

   172     {

   173     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::HandleKeyEventL()" );

   174     

   175     // The inherited HandleKeyEventL is private and cannot be called

   176     return EKeyWasNotConsumed;

   177     }

   178 

   179 // -----------------------------------------------------------------------------

   180 // CATConfigurationAppGuiAppUi::HandleViewDeactivation()

   181 // Override of the HandleViewDeactivation virtual function.

   182 // -----------------------------------------------------------------------------

   183 //

   184 void CATConfigurationAppGuiAppUi::HandleViewDeactivation( 

   185         const TVwsViewId& aViewIdToBeDeactivated, 

   186         const TVwsViewId& aNewlyActivatedViewId )

   187     {

   188     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::HandleViewDeactivation()" );

   189     

   190     CAknViewAppUi::HandleViewDeactivation( 

   191             aViewIdToBeDeactivated, 

   192             aNewlyActivatedViewId );

   193     }

   194 

   195 // -----------------------------------------------------------------------------

   196 // CATConfigurationAppGuiAppUi::SetProcessSubTestStartL()

   197 // Starts subtest for a process.

   198 // -----------------------------------------------------------------------------

   199 //

   200 void CATConfigurationAppGuiAppUi::SetProcessSubTestStartL( TUint aProcessId )

   201     {

   202     LOGSTR2( "ATCU CATConfigurationAppGuiAppUi::SetProcessSubTestStartL(%i)", 

   203     		aProcessId );

   204     

   205     // Load the kernel side device driver

   206     TInt loadErr = User::LoadLogicalDevice( KAnalyzeToolLddName );

   207     TBool driverLoaded( EFalse );

   208             

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

   210         {

   211         driverLoaded = ETrue;

   212         }

   213         

   214     RAnalyzeTool analyzeTool;    

   215     TInt driverOpen = analyzeTool.Open();

   216     TInt handleCount( KErrNone );

   217     

   218     if ( driverOpen == KErrNone )

   219         {       

   220         TATProcessHandlesBuf params;

   221         params().iProcessId = aProcessId;

   222         

   223         analyzeTool.GetCurrentHandleCount( params );

   224         handleCount = params().iCurrentHandleCount;

   225         LOGSTR2( "CATConfigurationAppGuiAppUi::SetProcessSubTestStartL - %i current handle(s)",

   226                 params().iCurrentHandleCount );       

   227         }

   228     

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

   230     if ( KErrNone == startErr )

   231         {

   232         iSubTestProcesses.Append( aProcessId );    

   233         }

   234     else if ( KErrNotSupported == startErr )

   235         {

   236         ShowErrorNoteL( R_CANT_START_SUBTEST_NOTSUPPORTED );

   237         }

   238     else // Could not start for a process

   239         {

   240         ShowErrorNoteL( R_CANT_START_SUBTEST_PROCESSID );  

   241         }

   242     

   243     // The count of device driver users

   244     TClientCountBuf count;

   245     

   246     // Check the flag

   247     if ( driverOpen == KErrNone )

   248         {

   249         analyzeTool.ClientCount( count );

   250         analyzeTool.Close();

   251         }  

   252     // Check the flag

   253     if ( driverLoaded )

   254         {

   255         // Check if there is another user for device driver

   256         if ( count().iClientCount <= 1 )

   257             {

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

   259             User::FreeLogicalDevice( KAnalyzeToolLddName );

   260             }

   261         }

   262     }

   263 

   264 // -----------------------------------------------------------------------------

   265 // CATConfigurationAppGuiAppUi::SetProcessSubTestStopL()

   266 // Stops subtest for a process.

   267 // -----------------------------------------------------------------------------

   268 //

   269 void CATConfigurationAppGuiAppUi::SetProcessSubTestStopL( TUint aProcessId )

   270     {

   271     LOGSTR2( "ATCU CATConfigurationAppGuiAppUi::SetProcessSubTestStopL(%i)", 

   272     		aProcessId );

   273     

   274     // Load the kernel side device driver

   275     TInt loadErr = User::LoadLogicalDevice( KAnalyzeToolLddName );

   276     TBool driverLoaded( EFalse );

   277             

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

   279         {

   280         driverLoaded = ETrue;

   281         }

   282         

   283     RAnalyzeTool analyzeTool;

   284     

   285     TInt driverOpen = analyzeTool.Open();

   286     TInt handleCount( KErrNone );

   287     

   288     if ( driverOpen == KErrNone )

   289         {  

   290         TATProcessHandlesBuf params;

   291         params().iProcessId = aProcessId;

   292         

   293         analyzeTool.GetCurrentHandleCount( params );

   294         handleCount = params().iCurrentHandleCount;

   295         LOGSTR2( "CATConfigurationAppGuiAppUi::SetProcessSubTestStopL - %i current handle(s)",

   296                 params().iCurrentHandleCount );      

   297         }

   298         

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

   300     if ( KErrNone == stopErr )

   301         {

   302         TInt index = iSubTestProcesses.Find( aProcessId );

   303         if ( index > KErrNotFound )

   304             {

   305             iSubTestProcesses.Remove( index );

   306             if ( iSubTestProcesses.Count() == KErrNone )

   307                 iSubTestProcesses.Reset();

   308             }             

   309         }

   310     else

   311         {

   312         ShowErrorNoteL( R_CANT_STOP_SUBTEST_PROCESSID );     

   313         }

   314     

   315     // The count of device driver users

   316     TClientCountBuf count;

   317     

   318     // Check the flag

   319     if ( driverOpen == KErrNone )

   320         {

   321         analyzeTool.ClientCount( count );

   322         analyzeTool.Close();

   323         }  

   324     // Check the flag

   325     if ( driverLoaded )

   326         {

   327         // Check if there is another user for device driver

   328         if ( count().iClientCount <= 1 )

   329             {

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

   331             User::FreeLogicalDevice( KAnalyzeToolLddName );

   332             }

   333         }

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // CATConfigurationAppGuiAppUi::IsSubTestRunning()

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

   339 // -----------------------------------------------------------------------------

   340 //

   341 TInt CATConfigurationAppGuiAppUi::IsSubTestRunning( TUint aProcessId )

   342     {

   343     LOGSTR2( "ATCU CATConfigurationAppGuiAppUi::IsSubTestRunning(%i)", 

   344     		aProcessId );

   345     

   346     return iSubTestProcesses.Find( aProcessId );

   347     }

   348 

   349 // -----------------------------------------------------------------------------

   350 // CATConfigurationAppGuiAppUi::LoadSettingsL()

   351 // Loads application settings.

   352 // -----------------------------------------------------------------------------

   353 //

   354 TInt CATConfigurationAppGuiAppUi::LoadSettingsL()

   355     {

   356     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::LoadSettingsL()" );

   357     

   358     /*CDictionaryStore* iniFile = Application()->OpenIniFileLC( CCoeEnv::Static()->FsSession() );

   359  

   360     if ( iniFile->IsPresentL( KUidATConfigurationAppGuiApplication ) )

   361         {

   362         RDictionaryReadStream readStream;

   363         readStream.OpenLC( *iniFile, KUidATConfigurationAppGuiApplication );

   364         // Load warning tones value

   365         iWarningTones = static_cast<TInt>( readStream.ReadInt32L() );

   366         // Load update interval value

   367         iUpdateInterval = static_cast<TInt>( readStream.ReadInt32L() );

   368         // Initialize other settings

   369  

   370         CleanupStack::PopAndDestroy( &readStream );

   371         }

   372     else

   373         {

   374         // ini doesn't exist, so use default values

   375         iWarningTones = 0;

   376         iUpdateInterval = 0;

   377         }

   378  

   379     CleanupStack::PopAndDestroy(iniFile);*/      

   380         

   381     return KErrNone;

   382     }

   383 

   384 // -----------------------------------------------------------------------------

   385 // CATConfigurationAppGuiAppUi::ShowErrorNoteL()

   386 // Shows error note.

   387 // -----------------------------------------------------------------------------

   388 //

   389 void CATConfigurationAppGuiAppUi::ShowErrorNoteL( TInt aResourceId )

   390     {

   391     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::ShowErrorNoteL()" );

   392     

   393     CAknErrorNote* errorNote = new ( ELeave ) CAknErrorNote();

   394     HBufC* errorText = StringLoader::LoadLC( aResourceId );

   395     errorNote->SetTextL( errorText->Des() );

   396     errorNote->ExecuteLD();

   397     CleanupStack::PopAndDestroy( errorText );      

   398     }

   399 

   400 //-----------------------------------------------------------------------------

   401 // CATConfigurationAppGuiAppUi::HandleForegroundEventL

   402 // Handles fore ground events

   403 //-----------------------------------------------------------------------------

   404 //

   405 void CATConfigurationAppGuiAppUi::HandleForegroundEventL( TBool aForeground )

   406     {  

   407     LOGSTR2( "ATCU CATConfigurationAppGuiAppUi::HandleForegroundEventL(%i)", 

   408     		aForeground );

   409     

   410     if ( aForeground )

   411         {

   412         // Start timer when processes view gains foreground

   413         if ( iDeactivatedId.iViewUid == TUid::Uid( EATConfigurationAppGuiListBoxViewId ) )

   414             {

   415             StartTimerL();    

   416             }

   417         }

   418     else

   419         {

   420         // Cancel timer when not in foreground

   421         TVwsViewId viewId;

   422         GetActiveViewId( viewId );

   423         // Save deactivated view's Id

   424         iDeactivatedId = viewId;

   425         TimerNotifyL( EFalse );        

   426         }

   427     }

   428 

   429 //-----------------------------------------------------------------------------

   430 // CATConfigurationAppGuiAppUi::StartTimerL

   431 // Starts timer with a specific time interval

   432 //-----------------------------------------------------------------------------

   433 //

   434 void CATConfigurationAppGuiAppUi::StartTimerL()

   435     {   

   436     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::StartTimerL()" );

   437     

   438     if ( iPeriodicTimer->IsActive() )

   439         {

   440         iPeriodicTimer->Cancel();

   441         }

   442     iPeriodicTimer->Start( KATDefaultUpdatingInterval, 

   443             KATDefaultUpdatingInterval, TCallBack( CallBackFunctionL, this ) );  

   444     }

   445     

   446 //-----------------------------------------------------------------------------

   447 // CATConfigurationAppGuiAppUi::TimerNotifyL

   448 // Periodic timer's callback function

   449 //-----------------------------------------------------------------------------

   450 //

   451 void CATConfigurationAppGuiAppUi::TimerNotifyL( TBool aPeriod )

   452     {

   453     LOGSTR2( "ATCU CATConfigurationAppGuiAppUi::TimerNotifyL(%i)", 

   454     		aPeriod );

   455     

   456     if ( iPeriodicTimer->IsActive() )

   457         {

   458         iPeriodicTimer->Cancel();

   459         }   

   460     if ( aPeriod )

   461         {

   462         if ( iATConfigurationAppGuiListBoxView )

   463             {

   464             iATConfigurationAppGuiListBoxView->UpdateViewL();

   465             }

   466         StartTimerL();

   467         }

   468     }

   469 

   470 // -----------------------------------------------------------------------------

   471 // CATConfigurationAppGuiAppUi::StopAllSubtestsL()

   472 // Stops all subtests which are running

   473 // -----------------------------------------------------------------------------

   474 //

   475 void CATConfigurationAppGuiAppUi::StopAllSubtestsL()

   476     {

   477     LOGSTR1( "ATCU CATConfigurationAppGuiAppUi::StopAllSubtestsL()" );

   478     

   479     TInt index( KErrNone );

   480     RArray<TATProcessInfo> processes;

   481     TInt err( iStorageServer.GetProcessesL( processes ) );

   482     LOGSTR2( "iStorageServer.GetProcessesL(%i)", err ); 

   483     

   484     // Load the kernel side device driver

   485     TInt loadErr( User::LoadLogicalDevice( KAnalyzeToolLddName ) );

   486     TBool driverLoaded( EFalse );

   487     LOGSTR2( "ATCU CATConfigurationAppGuiAppUi::StopAllSubtestsL() loadErr(%i)", 

   488     		loadErr );

   489             

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

   491         {

   492         driverLoaded = ETrue;

   493         }

   494     

   495     RAnalyzeTool analyzeTool;    

   496     TInt driverOpen( analyzeTool.Open() );

   497     

   498     while ( index < processes.Count() )

   499         {

   500         TUint processId = processes[ index ].iProcessId;

   501         TInt handleCount( KErrNone );

   502         

   503         if ( driverOpen == KErrNone )

   504             {  

   505             TATProcessHandlesBuf params;

   506             params().iProcessId = processId;

   507             // Get process handle count

   508             analyzeTool.GetCurrentHandleCount( params );

   509             handleCount = params().iCurrentHandleCount;

   510             LOGSTR2( "ATCU CATConfigurationAppGuiAppUi::StopAllSubtestsL() handleCount( %i )",

   511             		handleCount );      

   512             }        

   513         

   514         err = iStorageServer.StopSubTest( processId, KSubTestId, handleCount );

   515         LOGSTR2( "ATCU > iStorageServer.StopSubTest( %i )", err ); 

   516         

   517         TInt find( iSubTestProcesses.Find( processId ) );

   518         if ( find > KErrNotFound )

   519             {

   520             iSubTestProcesses.Remove( find );

   521             if ( iSubTestProcesses.Count() == KErrNone )

   522                 {

   523                 iSubTestProcesses.Reset();

   524                 }  

   525             } 

   526         index++;

   527         }

   528     

   529     // Close processes array

   530     processes.Close();

   531 

   532     // The count of device driver users

   533     TClientCountBuf count;

   534     

   535     // Check the flag

   536     if ( driverOpen == KErrNone )

   537         {

   538         analyzeTool.ClientCount( count );

   539         analyzeTool.Close();

   540         }  

   541     // Check the flag

   542     if ( driverLoaded )

   543         {

   544         // Check if there is another user for device driver

   545         if ( count().iClientCount <= 1 )

   546             {

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

   548             err = User::FreeLogicalDevice( KAnalyzeToolLddName );

   549             LOGSTR2( "ATCU > FreeLogicalDevice( %i )", err ); 

   550             }

   551         }

   552     }

   553 

   554 // End of File