--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/devencdiskutils/DevEncStarter/src/DevEncStarterMemoryEntity.cpp Tue Jan 26 15:20:08 2010 +0200
@@ -0,0 +1,393 @@
+/*
+* Copyright (c) 2007 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 CDevEncUiMemoryEntity
+*
+*/
+
+
+#include "DevEncLog.h"
+#include "DevEncStarterMemoryEntity.h"
+#include "DevEncUiMemInfoObserver.h"
+
+#include <DevEncDiskUtils.h>
+#include <DevEncSession.h>
+#include <f32file.h> // for TDriveNumer
+#include <DevEncEngineConstants.h>
+
+// Local definitions
+const TInt KPercent100( 100 );
+const TTimeIntervalMicroSeconds32 KProgressInterval( 500000 ); // ms, 0.5 seconds
+const TTimeIntervalMicroSeconds32 KPollInterval( 2000000 ); // ms, 2 seconds
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::CDevEncStarterMemoryEntity()
+//
+// --------------------------------------------------------------------------
+CDevEncStarterMemoryEntity::CDevEncStarterMemoryEntity(
+ TDevEncUiMemoryType aType )
+ : iType( aType )
+ {
+ // TBI: Get the real states from the underlying SW levels
+ iState = EDecrypted;
+ }
+
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::~CDevEncStarterMemoryEntity()
+//
+// --------------------------------------------------------------------------
+CDevEncStarterMemoryEntity::~CDevEncStarterMemoryEntity()
+ {
+ if ( iPeriodic )
+ {
+ iPeriodic->Cancel();
+ delete iPeriodic;
+ }
+
+ iObservers.Close();
+ delete iSession;
+ delete iDiskStatusObserver;
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::NewL()
+//
+// --------------------------------------------------------------------------
+CDevEncStarterMemoryEntity* CDevEncStarterMemoryEntity::NewL(
+ TDevEncUiMemoryType aType )
+ {
+ CDevEncStarterMemoryEntity* self =
+ CDevEncStarterMemoryEntity::NewLC( aType );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::NewLC()
+//
+// --------------------------------------------------------------------------
+CDevEncStarterMemoryEntity* CDevEncStarterMemoryEntity::NewLC(
+ TDevEncUiMemoryType aType )
+ {
+ CDevEncStarterMemoryEntity* self =
+ new ( ELeave ) CDevEncStarterMemoryEntity( aType );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::ConstructL()
+//
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::ConstructL()
+ {
+ DFLOG( ">>CDevEncStarterMemoryEntity::ConstructL" );
+ switch( iType )
+ {
+ case EPhoneMemory: iSession = new ( ELeave ) CDevEncSession( /*EDriveC*/EDriveE );
+ iDiskStatusObserver = CDiskStatusObserver::NewL( this, /*EDriveC*/EDriveE );
+ break;
+
+ case EPrimaryPhoneMemory: iSession = new ( ELeave ) CDevEncSession( EDriveC );
+ iDiskStatusObserver = CDiskStatusObserver::NewL( this, EDriveC );
+ break;
+
+ case EMemoryCard: iSession = new ( ELeave ) CDevEncSession( /*EDriveE*/EDriveF );
+ iDiskStatusObserver = CDiskStatusObserver::NewL( this, /*EDriveE*/EDriveF );
+ break;
+ }
+
+ User::LeaveIfError( iSession->Connect() );
+
+ // Get initial memory state
+ TInt nfeDiskStatus( EUnmounted );
+#ifndef __WINS__
+ TInt err = iSession->DiskStatus( nfeDiskStatus );
+ if ( err )
+ {
+ DFLOG2( "DevEncStarter: Could not get disk status, error %d", err );
+ nfeDiskStatus = EDecrypted;
+ //User::Leave( err );
+ }
+#else
+ nfeDiskStatus = EDecrypted;
+#endif
+ SetState( nfeDiskStatus );
+
+ if ( ( iState == EEncrypting ) ||
+ ( iState == EDecrypting ) )
+ {
+ // If the app was started in the middle of an ongoing operation,
+ // start polling the progress
+ StartPolling( KProgressInterval );
+ }
+ else
+ {
+ // Otherwise poll every once in a while to see if the status changes
+ //StartPolling( KPollInterval );
+ }
+
+ DFLOG( "<<CDevEncStarterMemoryEntity::ConstructL" );
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::AddObserverL()
+//
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::AddObserverL( MDevEncUiMemInfoObserver* aInfoObserver )
+ {
+ DFLOG( "CDevEncStarterMemoryEntity::AddObserverL" );
+ if ( !aInfoObserver )
+ {
+ User::Leave( KErrArgument );
+ }
+ iObservers.AppendL( aInfoObserver );
+
+ // The new observer probably wants to know the current states
+ UpdateMemoryInfo();
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::RemoveObserver()
+//
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::RemoveObserver( MDevEncUiMemInfoObserver* aInfoObserver )
+ {
+ if ( !aInfoObserver )
+ {
+ return;
+ }
+ TInt index( iObservers.Find( aInfoObserver ) );
+ if ( index != KErrNotFound )
+ {
+ iObservers.Remove( index );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::StartPolling()
+// Starts a timer to periodically update the memory state in the UI
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::StartPolling(
+ TTimeIntervalMicroSeconds32 aInterval )
+ {
+ DFLOG( "CDevEncStarterMemoryEntity::StartPolling" );
+ TInt error( KErrNone );
+ TRAP( error, DoStartPollingL( aInterval ) );
+ DFLOG2( "CDevEncUiMemoryEntity::StartPolling result %d", error );
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::DoStartPollingL()
+// Starts a timer to periodically update the memory state in the UI
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::DoStartPollingL(
+ TTimeIntervalMicroSeconds32 aInterval )
+ {
+ DFLOG( "CDevEncStarterMemoryEntity::DoStartPollingL" );
+ TCallBack pollCallBack( PollTick, static_cast<TAny*>( this ) );
+ TCallBack progressCallBack( ProgressTick, static_cast<TAny*>( this ) );
+
+ if ( !iPeriodic )
+ {
+ iPeriodic = CPeriodic::NewL( EPriorityNormal );
+ }
+ iPeriodic->Cancel();
+
+ if ( aInterval == KProgressInterval )
+ {
+ iPeriodic->Start( 0, aInterval, progressCallBack );
+ }
+ else
+ {
+ iPeriodic->Start( 0, aInterval, pollCallBack );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::ProgressTick()
+//
+// --------------------------------------------------------------------------
+TInt CDevEncStarterMemoryEntity::ProgressTick( TAny* aPtr )
+ {
+ CDevEncStarterMemoryEntity* self = static_cast<CDevEncStarterMemoryEntity*>( aPtr );
+ self->DoProgressTick();
+ return 0;
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::DoProgressTick()
+//
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::DoProgressTick()
+ {
+ CheckProgress();
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::PollTick()
+//
+// --------------------------------------------------------------------------
+TInt CDevEncStarterMemoryEntity::PollTick( TAny* aPtr )
+ {
+ CDevEncStarterMemoryEntity* self = static_cast<CDevEncStarterMemoryEntity*>( aPtr );
+ self->DoPollTick();
+ return 0;
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::DoPollTick()
+//
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::DoPollTick()
+ {
+ TInt nfeDiskStatus( EUnmounted );
+ TInt err = iSession->DiskStatus( nfeDiskStatus );
+ if ( err )
+ {
+ DFLOG2( "DevEncStarter: Could not get disk status, error %d", err );
+ // Ignore error
+ return;
+ }
+ if ( ( nfeDiskStatus == EEncrypting ) ||
+ ( nfeDiskStatus == EDecrypting ) )
+ {
+ // Some other component has started an encryption operation.
+ // Indicate this to the UI and start polling the progress.
+ SetState( nfeDiskStatus );
+ StartPolling( KProgressInterval );
+ }
+ else
+ {
+ if ( iState != nfeDiskStatus )
+ {
+ // The Mmc status has changed, but we are not in the middle of
+ // any operation. Just set the new state.
+ SetState( nfeDiskStatus );
+ }
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::SetState()
+//
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::SetState( TUint aState )
+ {
+ DFLOG3( "CDevEncStarterMemoryEntity::SetState, prev %d, new %d",
+ iState, aState );
+ iState = aState;
+ UpdateMemoryInfo();
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::CheckProgress()
+//
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::CheckProgress()
+ {
+ ASSERT( iSession );
+ ASSERT( iSession->Connected() );
+
+ TInt err = iSession->Progress( iPercentDone );
+
+ DFLOG( "CDevEncStarterMemoryEntity::CheckProgress" );
+
+ if ( err )
+ {
+ DFLOG( "DevEncStarter: Could not get progress" );
+ iPeriodic->Cancel();
+ }
+ else if ( iPercentDone >= KPercent100 )
+ {
+ DFLOG( "DevEncStarter: Operation complete" );
+ iPeriodic->Cancel();
+ iPercentDone = 0;
+
+ if( iSession->DriveNumber() == EDriveC )
+ {
+ // Finalize the phone memory
+ DFLOG( "DevEncStarter: DiskFinalize" );
+ err = CDevEncDiskUtils::DiskFinalize( iSession->DriveNumber() );
+ if ( err )
+ {
+ DFLOG2( "DevEncStarter: Finalization failed, error %d", err );
+ }
+ }
+
+ // Restart the polling at a slower pace
+ // StartPolling( KPollInterval );
+ }
+ else // Not yet finished...
+ {
+ UpdateMemoryInfo();
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::UpdateMemoryInfo()
+//
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::UpdateMemoryInfo()
+ {
+ DFLOG( "CDevEncStarterMemoryEntity::UpdateMemoryInfo()" );
+ for ( TInt i = 0; i < iObservers.Count(); i++ )
+ {
+ iObservers[i]->UpdateInfo( iType, iState, iPercentDone );
+ }
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::State()
+//
+// --------------------------------------------------------------------------
+TUint CDevEncStarterMemoryEntity::State() const
+ {
+ return iState;
+ }
+
+// --------------------------------------------------------------------------
+// CDevEncStarterMemoryEntity::DiskStatusChangedL()
+// From MDiskStatusObserver
+// --------------------------------------------------------------------------
+void CDevEncStarterMemoryEntity::DiskStatusChangedL( TInt aNfeStatus )
+ {
+ if ( ( aNfeStatus == EEncrypting ) ||
+ ( aNfeStatus == EDecrypting ) )
+ {
+ // Some other component has started an encryption operation.
+ // Indicate this to the UI and start polling the progress.
+ DFLOG2( "CDevEncStarterMemoryEntity::DiskStatusChangedL => status = %d",
+ aNfeStatus );
+ SetState( aNfeStatus );
+ StartPolling( KProgressInterval );
+ }
+ else
+ {
+ DFLOG2( "CDevEncStarterMemoryEntity::DiskStatusChangedL => status = %d",
+ aNfeStatus );
+
+ if( iState != aNfeStatus )
+ {
+ DFLOG2( "CDevEncStarterMemoryEntity::DiskStatusChangedL => status changed, iState was %d", iState );
+ SetState( aNfeStatus );
+ }
+ }
+ }
+
+// End of File
+
+
+