/*

* 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