deviceencryption/DevEncUi/src/DevEncUiMainViewContainer.cpp
branchRCL_3
changeset 38 491b3ed49290
parent 36 95243422089a
child 39 65326cf895ed
equal deleted inserted replaced
36:95243422089a 38:491b3ed49290
     1 /*
       
     2 * Copyright (c) 2005 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:  Implementation of CDevEncUiMainViewContainer.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 // INCLUDE FILES
       
    20 
       
    21 // Class includes
       
    22 #include "DevEncUiMainViewContainer.h"
       
    23 
       
    24 //System includes
       
    25 #include <centralrepository.h>
       
    26 #include <coemain.h>
       
    27 #include <eikenv.h>
       
    28 #include <DevEncEngineConstants.h>
       
    29 #include <StringLoader.h>
       
    30 #include <devencui.rsg>
       
    31 
       
    32 //User includes
       
    33 #include "DevEncLog.h"
       
    34 #include "DevEncUi.pan"
       
    35 #include "DevEncUiAppui.h"
       
    36 #include "DevEncUiDocument.h"
       
    37 #include "DevEncUiMainView.h"
       
    38 #include "DevEncUiSettingItemList.h"
       
    39 #include "DevEncUiMemoryEntity.h"
       
    40 
       
    41 // Local definitions
       
    42 const TInt KPercent100( 100 );
       
    43 
       
    44 // ================= MEMBER FUNCTIONS =======================
       
    45 
       
    46 // --------------------------------------------------------------------------
       
    47 // CDevEncUiMainViewContainer::NewLC()
       
    48 // --------------------------------------------------------------------------
       
    49 //
       
    50 CDevEncUiMainViewContainer* CDevEncUiMainViewContainer::NewLC(
       
    51                                 const TRect& aRect,
       
    52                                 RArray<CDevEncUiMemoryEntity*>& aMemEntities,
       
    53                                 MContainerEventCallback& aCallback,
       
    54                                 CRepository*& aCrSettings,
       
    55                                 TInt& aMmcStatus )
       
    56 	{
       
    57     CDevEncUiMainViewContainer* self =
       
    58         new ( ELeave ) CDevEncUiMainViewContainer( aMemEntities,
       
    59 												   aCallback,
       
    60                                                    aCrSettings,
       
    61                                                    aMmcStatus );
       
    62 
       
    63     CleanupStack::PushL( self );
       
    64     self->ConstructL(aRect);
       
    65     return self;
       
    66 	}
       
    67 
       
    68 // --------------------------------------------------------------------------
       
    69 // CDevEncUiMainViewContainer::NewL()
       
    70 // --------------------------------------------------------------------------
       
    71 //
       
    72 CDevEncUiMainViewContainer* CDevEncUiMainViewContainer::NewL(
       
    73                                 const TRect& aRect,
       
    74                                 RArray<CDevEncUiMemoryEntity*>& aMemEntities,
       
    75                                 MContainerEventCallback& aCallback,
       
    76                                 CRepository*& aCrSettings,
       
    77                                 TInt& aMmcStatus )
       
    78 	{
       
    79     CDevEncUiMainViewContainer* self = NewLC( aRect,
       
    80 											  aMemEntities,
       
    81                                               aCallback,
       
    82                                               aCrSettings,
       
    83                                               aMmcStatus );
       
    84     CleanupStack::Pop( self );
       
    85     return self;
       
    86 	}
       
    87 
       
    88 
       
    89 // --------------------------------------------------------------------------
       
    90 // CDevEncUiMainViewContainer::ConstructL()
       
    91 // --------------------------------------------------------------------------
       
    92 //
       
    93 void CDevEncUiMainViewContainer::ConstructL(const TRect& aRect)
       
    94 	{
       
    95     // Create a window for this application view
       
    96     CreateWindowL();
       
    97     // TBD: Give the list some settings
       
    98     iSettingItemList = new ( ELeave ) CDevEncUiSettingItemList();
       
    99     iSettingItemList->SetMopParent( this );
       
   100     iSettingItemList->ConstructFromResourceL( R_DEVENCUI_SETTING_ITEM_LIST );
       
   101     SetRect( aRect );
       
   102     ActivateL();
       
   103  	}
       
   104 
       
   105 
       
   106 // --------------------------------------------------------------------------
       
   107 // CDevEncUiMainViewContainer::CDevEncUiMainViewContainer()
       
   108 // --------------------------------------------------------------------------
       
   109 //
       
   110 CDevEncUiMainViewContainer::CDevEncUiMainViewContainer(
       
   111 								RArray<CDevEncUiMemoryEntity*>& aMemEntities,
       
   112                                 MContainerEventCallback& aCallback,
       
   113                                 CRepository*& aCrSettings,
       
   114                                 TInt& aMmcStatus )
       
   115 	: iMemEntities( aMemEntities ),
       
   116 	  iCallback( aCallback ),
       
   117       iCrSettings( aCrSettings ),
       
   118       iMmcStatus( aMmcStatus )
       
   119 	{
       
   120     // No implementation required
       
   121 	}
       
   122 
       
   123 // --------------------------------------------------------------------------
       
   124 // CDevEncUiMainViewContainer::CDevEncUiMainViewContainer()
       
   125 // --------------------------------------------------------------------------
       
   126 //
       
   127 CDevEncUiMainViewContainer::~CDevEncUiMainViewContainer()
       
   128 	{
       
   129     delete iSettingItemList;
       
   130 	}
       
   131 
       
   132 // --------------------------------------------------------------------------
       
   133 // CDevEncUiMainViewContainer::CountComponentControls()
       
   134 // --------------------------------------------------------------------------
       
   135 //
       
   136 TInt CDevEncUiMainViewContainer::CountComponentControls() const
       
   137 	{
       
   138 	return 1;
       
   139 	}
       
   140 
       
   141 // --------------------------------------------------------------------------
       
   142 // CDevEncUiMainViewContainer::ComponentControl()
       
   143 // --------------------------------------------------------------------------
       
   144 //
       
   145 CCoeControl* CDevEncUiMainViewContainer::ComponentControl( TInt aIndex ) const
       
   146 	{
       
   147 	CCoeControl* returnedItem( NULL );
       
   148 	switch (aIndex)
       
   149 		{
       
   150 		case 0:
       
   151 			returnedItem = iSettingItemList;
       
   152 			break;
       
   153 		default:
       
   154 			break;
       
   155 		}
       
   156 	return returnedItem;
       
   157 	}
       
   158 
       
   159 // --------------------------------------------------------------------------
       
   160 // CDevEncUiMainViewContainer::SizeChanged()
       
   161 // --------------------------------------------------------------------------
       
   162 //
       
   163 void CDevEncUiMainViewContainer::SizeChanged()
       
   164     {
       
   165     if ( iSettingItemList )
       
   166         {
       
   167         TRect mainPaneRect; 
       
   168         AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, 
       
   169                                            mainPaneRect );        
       
   170         iSettingItemList->SetRect( mainPaneRect );
       
   171         }
       
   172     }
       
   173 
       
   174 // --------------------------------------------------------------------------
       
   175 // CDevEncUiMainViewContainer::HandleResourceChange()
       
   176 // --------------------------------------------------------------------------
       
   177 //
       
   178 void CDevEncUiMainViewContainer::HandleResourceChange( TInt aType )
       
   179     {    
       
   180     if ( aType == KEikDynamicLayoutVariantSwitch )
       
   181         {
       
   182         if ( iSettingItemList )
       
   183             {
       
   184             TRect mainPaneRect; 
       
   185             AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, 
       
   186                                                mainPaneRect );
       
   187             iSettingItemList->SetRect( mainPaneRect ); 
       
   188             iSettingItemList->HandleResourceChange( aType );
       
   189             }
       
   190         }
       
   191     }
       
   192 
       
   193 // --------------------------------------------------------------------------
       
   194 // CDevEncUiMainViewContainer::OfferKeyEventL()
       
   195 // --------------------------------------------------------------------------
       
   196 //
       
   197 TKeyResponse CDevEncUiMainViewContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent,
       
   198                                                           TEventCode aType )
       
   199     {
       
   200     if ( aKeyEvent.iCode == EKeyDevice3 /* OK key */ || 
       
   201     	 aKeyEvent.iCode == EKeyEnter /* Enter key*/ )
       
   202         {
       
   203         // User selected a list item. Proceed to toggle the status
       
   204         TInt selectedItem = iSettingItemList->SelectedItem();
       
   205         if ( selectedItem < 0 )
       
   206             {
       
   207             return EKeyWasConsumed;
       
   208             }
       
   209         TDevEncUiMemoryType type = static_cast<TDevEncUiMemoryType>( selectedItem );
       
   210         iCallback.EncryptionStatusChangeReq( type );
       
   211         return EKeyWasConsumed;
       
   212         }
       
   213     else
       
   214         {
       
   215         if ( iSettingItemList )
       
   216             return iSettingItemList->OfferKeyEventL( aKeyEvent, aType );
       
   217         else
       
   218             return EKeyWasNotConsumed;
       
   219         }
       
   220     }
       
   221 
       
   222  // --------------------------------------------------------------------------
       
   223  // CDevEncUiMainViewContainer::SelectedItem()
       
   224  // --------------------------------------------------------------------------
       
   225  //
       
   226 TInt CDevEncUiMainViewContainer::SelectedItem()
       
   227     {
       
   228     if ( !iSettingItemList )
       
   229         {
       
   230         return -1;
       
   231         }
       
   232     return iSettingItemList->SelectedItem();
       
   233     }
       
   234 
       
   235 // --------------------------------------------------------------------------
       
   236 // CDevEncUiMainViewContainer::ChangeSelectedItemL()
       
   237 // --------------------------------------------------------------------------
       
   238 //
       
   239 TBool CDevEncUiMainViewContainer::ChangeSelectedItemL()
       
   240     {
       
   241     TBool itemChanged( EFalse );
       
   242     if ( !iSettingItemList )
       
   243         {
       
   244         return itemChanged;
       
   245         }
       
   246     // Get index of currently selected item
       
   247     TInt selectedItem = iSettingItemList->SelectedItem();
       
   248     if ( selectedItem < 0 )
       
   249         {
       
   250         User::Leave( KErrNotFound );
       
   251         }
       
   252 
       
   253     // Fetch the current setting for later comparison
       
   254     TBool currentSetting( EFalse );
       
   255     iSettingItemList->ItemState( selectedItem, currentSetting );
       
   256 
       
   257     // Let the user change the value (synchronously during this call)
       
   258     iSettingItemList->ChangeSelectedItemL();
       
   259 
       
   260     // Compare the new setting for changes
       
   261     TBool newSetting( EFalse );
       
   262     iSettingItemList->ItemState( selectedItem, newSetting );
       
   263 
       
   264     // Notify our callback observer if the setting was changed. This always
       
   265     // eventually results in a call to UpdateInfo, which means that if the
       
   266     // user decides to interrupt the operation, the values in the setting
       
   267     // item list are updated accordingly.
       
   268     if ( newSetting != currentSetting )
       
   269         {
       
   270         itemChanged = ETrue;
       
   271         }
       
   272     return itemChanged;
       
   273     }
       
   274 
       
   275 // --------------------------------------------------------------------------
       
   276 // CDevEncUiMainViewContainer::UpdateInfo()
       
   277 // --------------------------------------------------------------------------
       
   278 //
       
   279 void CDevEncUiMainViewContainer::UpdateInfo( TDevEncUiMemoryType aType,
       
   280                                              TUint aState,
       
   281                                              TUint aProgress /* = 0*/ )
       
   282     {
       
   283     DFLOG( ">>CDevEncUiMainViewContainer::UpdateInfoL" );
       
   284     TInt err( KErrNone );
       
   285     TRAP( err, DoUpdateInfoL( aType, aState, aProgress ) );
       
   286     if ( err )
       
   287         {
       
   288         DFLOG2( "CDevEncUiMainViewContainer::UpdateInfoL => error is %d", err );
       
   289         // TBI: Log the error
       
   290         }
       
   291     DFLOG( "<<CDevEncUiMainViewContainer::UpdateInfoL" );   
       
   292     }
       
   293 
       
   294 // --------------------------------------------------------------------------
       
   295 // CDevEncUiMainViewContainer::DoUpdateInfoL()
       
   296 // --------------------------------------------------------------------------
       
   297 //
       
   298 void CDevEncUiMainViewContainer::DoUpdateInfoL( TDevEncUiMemoryType aType,
       
   299                                                 TUint aState,
       
   300                                                 TUint aProgress /*= 0*/ )
       
   301     {
       
   302     DFLOG( ">>CDevEncUiMainViewContainer::DoUpdateInfoL" );
       
   303     DFLOG2( "CDevEncUiMainViewContainer::DoUpdateInfoL, type %d", aType );
       
   304     DFLOG3( "New state %d, new progress %d", aState, aProgress );
       
   305 
       
   306     if ( aType > EPrimaryPhoneMemory )
       
   307         {
       
   308         // Unknown memory type
       
   309         User::Leave( KErrUnknown );
       
   310         }
       
   311     if ( aState > ECorrupted )
       
   312         {
       
   313         // Unknown state
       
   314         User::Leave( KErrCorrupt );
       
   315         }
       
   316     if ( aProgress > KPercent100 )
       
   317         {
       
   318         // Invalid progress value
       
   319         User::Leave( KErrOverflow );
       
   320         }
       
   321     
       
   322     DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => Passed first area of error ");
       
   323     
       
   324     HBufC* stateText( NULL );
       
   325    
       
   326     switch ( aState )
       
   327         {
       
   328     	case EDecrypted:
       
   329     		{
       
   330     		if ( ( aType == EMemoryCard ) && ( iMmcStatus == EMmcOk ) )
       
   331     			{
       
   332                 DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => Memory card OK "); 
       
   333                 // The Mmc is readable and decrypted, but there may be a key
       
   334                 // in the driver. In that case, we need to show "On" even
       
   335                 // though the card itself is not encrypted.
       
   336                 TBool mmcEncKeyInDriver( EFalse );
       
   337                 User::LeaveIfError(
       
   338                     iCrSettings->Get( KDevEncUserSettingMemoryCard,
       
   339                                       mmcEncKeyInDriver ) );
       
   340                 if ( mmcEncKeyInDriver )
       
   341                     {
       
   342                     DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => MMCKey in driver ");
       
   343                     // "On"
       
   344                     stateText = StringLoader::LoadLC(
       
   345                         R_DEVENCUI_TEXT_ENCRYPTION_ON,
       
   346                         iEikonEnv );
       
   347                     // Update the On/Off popup settings 
       
   348                     iSettingItemList->SetItemStateL( aType, ETrue );
       
   349                     }
       
   350                 else
       
   351                     {
       
   352                     DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => MMCKey NOT in driver ");
       
   353                     // "Off"
       
   354                     stateText = StringLoader::LoadLC(
       
   355                         R_DEVENCUI_TEXT_ENCRYPTION_OFF,
       
   356                         iEikonEnv );
       
   357                     // Update the On/Off popup settings 
       
   358                     iSettingItemList->SetItemStateL( aType, EFalse );
       
   359                     }
       
   360                 }
       
   361     		else if (aType == EMemoryCard)
       
   362     			{
       
   363     			stateText = StringLoader::LoadLC( R_DEVENCUI_TEXT_ENCRYPTION_OFF, iEikonEnv );
       
   364     			iSettingItemList->SetItemStateL( aType, EFalse );
       
   365     			}
       
   366             else
       
   367                 {
       
   368                 DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => Phone Memory or Mass Storage ");
       
   369                 if (aType == EPhoneMemory) // Mass Storage
       
   370                 	{
       
   371                 	if ( iMemEntities.Count() > EPrimaryPhoneMemory )
       
   372                 		{
       
   373                 		TUint phoneMemState = iMemEntities[EPrimaryPhoneMemory]->State();
       
   374                 		DFLOG2( "CDevEncUiMainViewContainer::DoUpdateInfoL, Now Mass Storage, need Phone Memory State: %d", phoneMemState);
       
   375                 		if (phoneMemState == ECorrupted)
       
   376                 			{
       
   377                 			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_CORRUPTED, iEikonEnv);
       
   378                 			}
       
   379                 		else
       
   380                 			{
       
   381                             stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_OFF, iEikonEnv);
       
   382                 			}
       
   383                 		}
       
   384                 	else
       
   385                 		{
       
   386                 		DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL, Now Mass Storage, no Phone Memory");
       
   387                         stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_OFF, iEikonEnv);
       
   388                 		}
       
   389                 	}
       
   390                 else // aType == EPrimaryPhoneMemory, means Phone Memory
       
   391                 	{
       
   392                 	if ( iMemEntities.Count() > EPhoneMemory )
       
   393                 		{
       
   394                 		TUint massStoreState = iMemEntities[EPhoneMemory]->State();
       
   395                 		DFLOG2( "CDevEncUiMainViewContainer::DoUpdateInfoL, Now Phone Memory, need Mass Storage State: %d", massStoreState);
       
   396                 		if (massStoreState == ECorrupted)
       
   397                 			{
       
   398                 			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_CORRUPTED, iEikonEnv);
       
   399                 			}
       
   400                 		else
       
   401                 			{
       
   402                 			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_OFF, iEikonEnv);
       
   403                 			}
       
   404                 		}
       
   405                 	else
       
   406                 		{
       
   407                 		DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL, Now Phone Memory, no Mass Storage");
       
   408                 		stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_OFF, iEikonEnv);
       
   409                 		}
       
   410                 	}
       
   411 
       
   412                 // Update the On/Off popup settings 
       
   413                 iSettingItemList->SetItemStateL( EPhoneMemory, EFalse );
       
   414                 }
       
   415             break;
       
   416             }
       
   417         case EEncrypting:
       
   418             {
       
   419             DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => EEncrypting ");
       
   420             stateText = StringLoader::LoadLC(
       
   421                 R_DEVENCUI_TEXT_ENCRYPT_PROCESS,
       
   422                 //R_DEVENCUI_TEXT_DECRYPT,
       
   423                 aProgress,
       
   424                 iEikonEnv );
       
   425             break;
       
   426             }
       
   427         case EEncrypted:
       
   428             {
       
   429             DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => Phone Memory or Mass Storage ");
       
   430             if (aType == EPhoneMemory) // Mass Storage
       
   431             	{
       
   432             	if ( iMemEntities.Count() > EPrimaryPhoneMemory )
       
   433             		{
       
   434             		TUint phoneMemState = iMemEntities[EPrimaryPhoneMemory]->State();
       
   435             		DFLOG2( "CDevEncUiMainViewContainer::DoUpdateInfoL, Now Mass Storage, need Phone Memory State: %d", phoneMemState);
       
   436             		if (phoneMemState == ECorrupted)
       
   437             			{
       
   438             			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_CORRUPTED, iEikonEnv);
       
   439             			}
       
   440             		else if (phoneMemState == EDecrypted)
       
   441             			{
       
   442             			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_OFF, iEikonEnv);
       
   443             			}
       
   444             		else
       
   445             			{
       
   446             			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_ON, iEikonEnv);
       
   447             			}
       
   448             		}
       
   449             	else
       
   450             		{
       
   451             		DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL, Now Mass Storage, no Phone Memory");
       
   452             		stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_ON, iEikonEnv);
       
   453             		}
       
   454             	}
       
   455             else  if (aType == EPrimaryPhoneMemory)// Phone Memory
       
   456             	{
       
   457             	if ( iMemEntities.Count() > EPhoneMemory )
       
   458             		{
       
   459             		TUint massStoreState = iMemEntities[EPhoneMemory]->State();
       
   460             		DFLOG2( "CDevEncUiMainViewContainer::DoUpdateInfoL, Now Phone Memory, need Mass Storage State: %d", massStoreState);
       
   461             		if (massStoreState == ECorrupted)
       
   462             			{
       
   463             			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_CORRUPTED, iEikonEnv);
       
   464             			}
       
   465             		else if (massStoreState == EDecrypted)
       
   466             			{
       
   467             			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_OFF, iEikonEnv);
       
   468             			}
       
   469             		else
       
   470             			{
       
   471             			stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_ON, iEikonEnv);
       
   472             			}
       
   473             		}
       
   474             	else
       
   475             		{
       
   476             		DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL, Now Phone Memory, no Mass Storage");
       
   477             		stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_ON, iEikonEnv);
       
   478             		}
       
   479             	}
       
   480             else // Memory Card
       
   481             	{
       
   482             	stateText = StringLoader::LoadLC(R_DEVENCUI_TEXT_ENCRYPTION_ON, iEikonEnv);
       
   483             	}
       
   484             // Update the On/Off popup settings 
       
   485             if ( aType != EPrimaryPhoneMemory )
       
   486             	{
       
   487             	iSettingItemList->SetItemStateL( aType, ETrue );
       
   488             	}
       
   489             else
       
   490             	{
       
   491             	iSettingItemList->SetItemStateL( EPhoneMemory, ETrue );
       
   492             	}
       
   493             break;
       
   494             }
       
   495         case EDecrypting:
       
   496             {
       
   497                 DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => EDecrypting ");
       
   498             stateText = StringLoader::LoadLC(
       
   499                 R_DEVENCUI_TEXT_DECRYPT_PROCESS,
       
   500                 aProgress,
       
   501                 iEikonEnv );
       
   502             break;
       
   503             }
       
   504         case ECorrupted: // fall through
       
   505         case EUnmounted:
       
   506         default:
       
   507             {
       
   508             if ( aType == EMemoryCard )
       
   509                 {
       
   510                     DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => MMC Corrupted ");
       
   511                 // Mmc is a) not inserted, b) corrupted or c) encrypted with
       
   512                 // another key. Check the user setting, and show "On" if any
       
   513                 // key is in the driver.
       
   514                 TBool mmcEncKeyInDriver( EFalse );
       
   515                 User::LeaveIfError(
       
   516                     iCrSettings->Get( KDevEncUserSettingMemoryCard,
       
   517                                       mmcEncKeyInDriver ) );
       
   518                 if ( mmcEncKeyInDriver )
       
   519                     {
       
   520                         DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => MMC On ");
       
   521                     // "On"
       
   522                     stateText = StringLoader::LoadLC(
       
   523                         R_DEVENCUI_TEXT_ENCRYPTION_ON,
       
   524                         iEikonEnv );
       
   525                     // Update the On/Off popup settings 
       
   526                     iSettingItemList->SetItemStateL( aType, ETrue );
       
   527                     }
       
   528                 else
       
   529                     {
       
   530                         DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => MMC Off ");
       
   531                     // "Off"
       
   532                     stateText = StringLoader::LoadLC(
       
   533                         R_DEVENCUI_TEXT_ENCRYPTION_OFF,
       
   534                         iEikonEnv );
       
   535                     // Update the On/Off popup settings 
       
   536                     iSettingItemList->SetItemStateL( aType, EFalse );
       
   537                     }
       
   538                 }
       
   539             else
       
   540                 {
       
   541                     DFLOG( "CDevEncUiMainViewContainer::DoUpdateInfoL => NON OF THE PREVIOUS");
       
   542                 stateText = StringLoader::LoadLC(
       
   543                     R_DEVENCUI_TEXT_CORRUPTED,
       
   544                     iEikonEnv );
       
   545                 }
       
   546             break;
       
   547             }
       
   548         } // End of switch
       
   549 
       
   550     if (aType != EPrimaryPhoneMemory)
       
   551     	{
       
   552     	iSettingItemList->SetItemTextL( aType, *stateText );
       
   553     	}
       
   554     else
       
   555     	{
       
   556     	iSettingItemList->SetItemTextL( EPhoneMemory, *stateText );
       
   557     	}
       
   558     CleanupStack::PopAndDestroy( stateText );
       
   559 
       
   560     DFLOG( ">>CDevEncUiMainViewContainer::DoUpdateInfoL" );
       
   561     }
       
   562 
       
   563 
       
   564 //End of File