diff -r 000000000000 -r 6a9f87576119 deviceencryption/DevEncUi/src/DevEncUiMainView.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/deviceencryption/DevEncUi/src/DevEncUiMainView.cpp Mon Jan 18 20:09:41 2010 +0200 @@ -0,0 +1,441 @@ +/* +* Copyright (c) 2005 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: Implementation of CDevEncUiMainView. +* +*/ + +// INCLUDES + +// Class include +#include "DevEncUiMainView.h" + +// System includes +#include +#include // CAknViewAppUi +#include +#include +#include +#include + +// User includes +#include "DevEncLog.h" +#include "DevEnc.hrh" +#include "DevEncUiEncryptionOperator.h" + +#include "DevEncUiMainViewContainer.h" +#include "DevEncUiMemoryEntity.h" + +// ================= MEMBER FUNCTIONS ======================= + +/** +* Destructor. Frees up memory for the iLabel. +*/ +CDevEncUiMainView::~CDevEncUiMainView() + { + for ( TInt i = 0; i < iMemEntities.Count(); i++ ) + { + iMemEntities[i]->RemoveObserver( iContainer ); + } + delete iContainer; + delete iEncOperator; + } + +/** +* Symbian OS 2 phase constructor. +* Constructs the CDevEncUiMainView using the NewLC method, popping +* the constructed object from the CleanupStack before returning it. +* +* @param aRect The rectangle for this window +* @return The newly constructed CDevEncUiMainView +*/ +CDevEncUiMainView* CDevEncUiMainView::NewL( + RArray& aMemEntities, + CRepository*& aCrSettings, + TInt& aMmcStatus ) + { + CDevEncUiMainView* self = CDevEncUiMainView::NewLC( aMemEntities, + aCrSettings, + aMmcStatus ); + CleanupStack::Pop( self ); + return self; + } + +/** +* Symbian OS 2 phase constructor. +* Constructs the CDevEncUiMainView using the constructor and ConstructL +* method, leaving the constructed object on the CleanupStack before returning it. +* +* @param aRect The rectangle for this window +* @return The newly constructed CDevEncUiMainView +*/ +CDevEncUiMainView* CDevEncUiMainView::NewLC( + RArray& aMemEntities, + CRepository*& aCrSettings, + TInt& aMmcStatus ) + { + CDevEncUiMainView* self = + new ( ELeave ) CDevEncUiMainView( aMemEntities, + aCrSettings, + aMmcStatus ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +CDevEncUiMainView::CDevEncUiMainView( RArray& aMemEntities, + CRepository*& aCrSettings, + TInt& aMmcStatus ) + : iMemEntities( aMemEntities ), + iCrSettings( aCrSettings ), + iMmcStatus( aMmcStatus ) + { + } + +/** +* Symbian OS 2nd phase constructor. +* Uses the superclass constructor to construct the view +*/ +void CDevEncUiMainView::ConstructL() + { + BaseConstructL( R_DEVENCUI_MAINVIEW ); + + iContainer = CDevEncUiMainViewContainer::NewL( AppUi()->ClientRect(), + iMemEntities, + *this, + iCrSettings, + iMmcStatus ); + iContainer->SetMopParent( this ); + + for ( TInt i = 0; i < iMemEntities.Count(); i++ ) + { + iMemEntities[i]->AddObserverL( iContainer ); + } + } + +/** +* Called by the framework +* @return The Uid for this view +*/ +TUid CDevEncUiMainView::Id() const + { + return TUid::Uid( EDevEncUiMainViewId ); + } + +/** +* Called by the framework when the view is activated. +* Adds the container to the control stack. +*/ +void CDevEncUiMainView::DoActivateL( const TVwsViewId& /*aPrevViewId*/, + TUid /*aCustomMessageId*/, + const TDesC8& /*aCustomMessage*/) + { + AppUi()->AddToStackL( *this, iContainer ); + + if ( iEikonEnv->StartedAsServerApp() ) + { + CEikButtonGroupContainer* cba = Cba(); + cba->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); + } + } + +/** +* Called by the framework when the view is deactivated. +* Removes the container from the control stack. +*/ +void CDevEncUiMainView::DoDeactivate() + { + if ( iContainer ) + { + AppUi()->RemoveFromStack( iContainer ); + } + } + +/** +* From CEikAppUi, takes care of command handling for this view. +* +* @param aCommand command to be handled +*/ +void CDevEncUiMainView::HandleCommandL( TInt aCommand ) + { + + switch ( aCommand ) + { + case EDevEncUiCommandChange: + { + // Show the toggle popup + if ( iContainer->ChangeSelectedItemL() ) + { + // The user made a new selection + TDevEncUiMemoryType memoryType = + static_cast( iContainer->SelectedItem() ); + EncryptionStatusChangeReq( memoryType ); + } + break; + } + default: + { + AppUi()->HandleCommandL( aCommand ); + break; + } + } + } + +void CDevEncUiMainView::DynInitMenuPaneL( TInt aResourceId, + CEikMenuPane* aMenuPane ) + { + if ( ! iContainer || + iMemEntities.Count() == 0 ) + { + return; + } + + // Disable the "Change" menu item if an encryption operation is ongoing + if ( aResourceId == R_DEVENCUI_MENU_MAIN ) + { + TBool proceed( ETrue ); + TInt dmControl( 0 ); + TInt err = iCrSettings->Get( KDevEncUiDmControl, dmControl ); + if ( err ) + { + DFLOG2( "Cenrep error %d", err ); + User::Leave( err ); + } + + // Check if phone memory encryption is controlled by dev management + if ( ( dmControl & KDmControlsPhoneMemory ) && + ( iContainer->SelectedItem() == EPhoneMemory ) ) + { + // Selected memory is controlled by DM -> disable "Change" + aMenuPane->SetItemDimmed( EDevEncUiCommandChange, ETrue ); + proceed = EFalse; + } + + // Check if memory card encryption is controlled by dev management + if ( ( dmControl & KDmControlsMemoryCard ) && + ( iContainer->SelectedItem() == EMemoryCard ) ) + { + // Selected memory is controlled by DM -> disable "Change" + aMenuPane->SetItemDimmed( EDevEncUiCommandChange, ETrue ); + proceed = EFalse; + } + + if ( !proceed ) + { + DFLOG( "Hiding Change, item is controlled by DM" ); + return; + } + + // Show the "Change" item if encryption status can be changed + TBool allowChange( EFalse ); + if ( ( iMemEntities[ EMemoryCard ]->State() == EUnmounted || + iMemEntities[ EMemoryCard ]->State() == EDecrypted || + iMemEntities[ EMemoryCard ]->State() == EEncrypted ) && + ( iMemEntities[ EPhoneMemory ]->State() == EDecrypted || + iMemEntities[ EPhoneMemory ]->State() == EEncrypted ) ) + { + allowChange = ETrue; + } + + if ( allowChange ) + { + aMenuPane->SetItemDimmed( EDevEncUiCommandChange, EFalse ); + } + else + { + aMenuPane->SetItemDimmed( EDevEncUiCommandChange, ETrue ); + } + } + } + + + +CDevEncUiAppUi& CDevEncUiMainView::GetAppUi() + { + CAknViewAppUi* aknViewAppUi = AppUi(); + CDevEncUiAppUi* appUi = reinterpret_cast( aknViewAppUi ); + return ( *appUi ); + } + +void CDevEncUiMainView::EncryptionStatusChangeReq( TDevEncUiMemoryType aType ) + { + // Can't do anything about errors here + TInt error( KErrNone ); + TRAP( error, DoEncryptionStatusChangeReqL( aType ) ); + if ( error ) + { + DFLOG2( "DoEncryptionStatusChangeReqL error %d", error ); + } + } + +// TBI: Async this function and create a subfunction with -L +void CDevEncUiMainView::DoEncryptionStatusChangeReqL( TDevEncUiMemoryType aType ) + { + DFLOG( "CDevEncUiMainView::DoEncryptionStatusChangeReqL" ); + + // Check if we are allowed to start an encryption operation + TInt dmControl( 0 ); + TInt err = iCrSettings->Get( KDevEncUiDmControl, dmControl ); + if ( err ) + { + DFLOG2( "Cenrep error %d", err ); + User::Leave( err ); + } + if ( DmControlsMemory( aType, dmControl ) ) + { + // Encryption controlled by admin + ErrorNoteL( R_DEVENCUI_NOTE_ADMIN_CONTROL ); + return; + } + + // Create the encryption operator if necessary + if ( ! iEncOperator ) + { + iEncOperator = CDevEncUiEncryptionOperator::NewL( *iEikonEnv, + *AppUi(), + iCrSettings ); + } + + // Get the currently highlighted memory type + CDevEncUiMemoryEntity* mem = iMemEntities[ aType ]; + + DFLOG3( "Mem type: %d, state: %d", aType, mem->State() ); + + if ( aType == EPhoneMemory ) + { + CDevEncUiMemoryEntity* phoneMemory = iMemEntities[ EPrimaryPhoneMemory]; + iEncOperator->HandlePhoneMemEncryptRequestL( mem, phoneMemory ); + } + else // aType = EMemoryCard + { + HandleMemoryCardEncryptRequestL( mem ); + } + } + +// -------------------------------------------------------------------------- +// CDevEncUiMainView::ErrorNoteL() +// TBI: Create base class and move this there +// -------------------------------------------------------------------------- +// +void CDevEncUiMainView::ErrorNoteL( TInt aResourceId ) + { + HBufC* message = StringLoader::LoadLC( aResourceId ); + CAknErrorNote* errorNote = new ( ELeave ) CAknErrorNote; + errorNote->ExecuteLD( *message ); + CleanupStack::PopAndDestroy( message ); + } + +// TBI: Create base class and move this there +TBool CDevEncUiMainView::DmControlsMemory( TDevEncUiMemoryType aType, + TInt aDmControlSetting ) + { + TBool result( EFalse ); + if ( ( aType == EPhoneMemory ) && + ( aDmControlSetting & KDmControlsPhoneMemory ) ) + { + result = ETrue; + } + if ( ( aType == EMemoryCard ) && + ( aDmControlSetting & KDmControlsMemoryCard ) ) + { + result = ETrue; + } + return result; + } + +// -------------------------------------------------------------------------- +// CDevEncUiMainView::HandleMemoryCardEncryptRequestL() +// -------------------------------------------------------------------------- +// +void CDevEncUiMainView::HandleMemoryCardEncryptRequestL( CDevEncUiMemoryEntity* aMem ) + { + // Check if the driver has a known encryption key + TInt mmcEncrOn( 0 ); + iCrSettings->Get( KDevEncUserSettingMemoryCard, mmcEncrOn ); + + if ( aMem->State() == EDecrypted || + aMem->State() == EUnmounted ) + { + if ( mmcEncrOn ) + { + // Mmc decrypted or ejected but encryption is on -> + // suggest destruction of key + DFLOG( "Mmc decrypted, encryption key set -> destroy key?" ); + if ( aMem->State() == EDecrypted ) + { + // Mmc inserted -> indicate that it is decrypted + // (see UI spec 2.12) + iEncOperator->DestroyKeyQueryL( ETrue ); + } + else + { + // Mmc ejected -> no need to show note + // (see UI spec 2.11) + iEncOperator->DestroyKeyQueryL( EFalse ); + } + } + else + { + // Mmc decrypted and encryption is off -> show encryption menu + DFLOG( "Mmc decrypted, encryption key not set -> enc menu" ); + AppUi()->ActivateLocalViewL( TUid::Uid( EDevEncUiEncrViewId ) ); + } + } + else if ( aMem->State() == EEncrypted ) + { + // Encryption is on -> show decryption menu + DFLOG( "Mmc encrypted -> decr menu" ); + AppUi()->ActivateLocalViewL( TUid::Uid( EDevEncUiDecrViewId ) ); + } + else if ( aMem->State() == ECorrupted ) + { + if ( mmcEncrOn ) + { + // Mmc seems to be encrypted with another key. + // Ask if the user wants to import another key. + // (See UI spec 2.10) + DFLOG( "CDevEncUiMainView::HandleMemoryCardEncryptRequestL => Mmc encrypted with another key, enc on -> import key" ); + iEncOperator->SuggestMmcImportKeyL( aMem, ETrue ); + } + else + { + // Mmc is probably encrypted with another key -> show encryption + // menu to let user choose a key + DFLOG( "Mmc encrypted, encryption key not set -> enc menu" ); + AppUi()->ActivateLocalViewL( TUid::Uid( EDevEncUiEncrViewId ) ); + } + } + else + { + DFLOG2( "Mmc busy, state = %d, no action", aMem->State() ); + } + // Depending on the user's selection, the memory may be in the same + // state as before or in a new state. This call will let all observers + // know what state the memory ended up in. + aMem->UpdateMemoryInfo(); + + } + +// -------------------------------------------------------------------------- +// Called by the framework when the application status pane +// size is changed. Passes the new client rectangle to the container. +// -------------------------------------------------------------------------- +void CDevEncUiMainView::HandleStatusPaneSizeChange() + { + if ( iContainer ) + { + iContainer->SetRect( ClientRect() ); + } + } + +// End of File