/*

* Copyright (c) 2006 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:  Memory state popup implementation

*

*/

// SYSTEM INCLUDES

#include <e32std.h>

#include <AknProgressDialog.h>

#include <aknlists.h>

#include <ConeResLoader.h>

#include <bautils.h>

#include <StringLoader.h>

#include <aknPopup.h>

#include <MemStatePopup.rsg>

#include <f32file.h>

#include <data_caging_path_literals.hrh> 

// USER INCLUDES

#include "msputil.h"

#include "cmemstatepopup.h"

#include "cmemstatepopupimpl.h"

#include "cmemscaneventreceiver.h"

//  CONSTANTS

_LIT( KDirAndFile,"Z:MemStatePopup.RSC" );

_LIT( KMemListSeparator, "\t" );

// Max length of a list row

// Has to be big enough to hold "%N %U"

const TInt KListItemMaxLength = 32;

// ---------------------------------------------------------------------------

CMemStatePopupImpl::~CMemStatePopupImpl( )

    {

    Cancel();

    // Close the resource

    iResLoader.Close( );

    if( iWaitDialog )

        {

        iWaitDialog->SetObserver( NULL );

        delete iWaitDialog;

        }

    delete iEventReceiver; // deletes also scan engine and server 

    delete iGroupNames;

    delete iListModel;

    delete iListBox;

    delete iScanResults;

    if( iOwnsUtil )

        {

        // Delete only if the actual dialog was launched

        delete iUtil;

        }

    // Try to delete also iPopup in case of leave

    // Must call CBase's destructor

    // because CAknPopupList destructor is protected

    delete ( CBase* ) iPopup;

    }

// ---------------------------------------------------------------------------

CMemStatePopupImpl::CMemStatePopupImpl( TDriveNumber aDrive, const TDesC& aTitle ) :

            CActive(EPriorityStandard),

            iFinished( EFalse ),

            iDrive( aDrive ),

            iTitle( const_cast<TDesC*> (&aTitle) ),

            iCoeEnv( *CCoeEnv::Static( ) ),

            iResLoader( iCoeEnv ),

            iOwnsUtil( ETrue )

    {

    CActiveScheduler::Add(this);

    }

// ---------------------------------------------------------------------------

// Used by GetUtilL

CMemStatePopupImpl::CMemStatePopupImpl( ) :

            CActive(EPriorityStandard),

            iFinished( EFalse ),

            iDrive( EDriveC ),

            iCoeEnv( *CCoeEnv::Static( ) ),

            iResLoader( iCoeEnv ),

            iOwnsUtil( EFalse )

    {

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::ConstructL( )

    {

    OpenResourceAndReadArrayL( );

    // Instantiate event receiver, memory scan engine and server

    iEventReceiver = CMemScanEventReceiver::NewL( *this );

    // Get data group names from engine

    iGroupNames = iEventReceiver->DataGroupsL( );

    // Create popup

    ConstructPopupL( );

    // Create wait dialog

    iWaitDialog = new( ELeave ) CAknWaitDialog(

                    reinterpret_cast< CEikDialog** >( &iWaitDialog ) );

    iWaitDialog->SetCallback( this );

    iWaitDialog->PrepareLC( R_MEMSTATE_WAIT_NOTE );

    StartObserver();

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::RunLD( TDriveNumber aDrive, const TDesC& aTitle )

    {

    CMemStatePopupImpl* self = new( ELeave ) CMemStatePopupImpl( aDrive, aTitle );

    CleanupStack::PushL( self );

    self->ConstructL( );

    // Run the actual process

    self->ExecuteL( );

    CleanupStack::PopAndDestroy( self );

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::GetUtilL( CMSPUtil*& aUtil )

    {

    CMemStatePopupImpl* self = new( ELeave ) CMemStatePopupImpl;

    CleanupStack::PushL( self );

    // Read the unit array from resource

    self->OpenResourceAndReadArrayL( );

    aUtil = self->iUtil; // iUtil is not deleted

    CleanupStack::PopAndDestroy( self );

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::StartL( )

    {

#ifdef _DEBUG

    RDebug::Print( _L( "Scanning started!" ) );

#endif

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::QuitL( TInt /*aReason*/ )

    {

#ifdef _DEBUG

    RDebug::Print( _L( "Scanning ended!" ) );

#endif

    if( !iFinished )

        {

        // Tell waitdialog that it can quit now

        iWaitDialog->ProcessFinishedL( );

        iFinished = ETrue;

        }

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::ErrorL( TInt aError )

    {

#ifdef _DEBUG

    RDebug::Print( _L( "Error scanning memory: %d" ), aError );

#endif

    // getting rid of UREL compiler warning

    if( !aError ) 

        {

        aError = KErrNone;

        }

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::DialogDismissedL( TInt aButtonId )

    {

    // Cancel is pressed while scanning is in progress

    if( iEventReceiver->ScanInProgress( ) )

        {

        iFinished = ETrue;

        iEventReceiver->Cancel( ); // Stop scanning

        }

    // Cancel is pressed while wait note is on screen (scanning may be completed)

    if( aButtonId == EAknSoftkeyCancel ) // instead of EAknSoftkeyDone

        {

        iPopup->CancelPopup( ); // Remove memory state popup from screen

        return;

        }

    // Get the new result array

    delete iScanResults;

    iScanResults = NULL;

    TRAPD( err, iScanResults = iEventReceiver->ScanResultL( ) );

    if( err != KErrNone )

        {

        iPopup->CancelPopup( ); // Remove memory state popup from screen

        return;

        }

    RefreshL( );

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::ConstructPopupL( )

    {

    iListBox = new( ELeave ) CMemStateListBox( );

    iPopup = CAknPopupList::NewL( iListBox, R_AVKON_SOFTKEYS_OK_EMPTY,

                            AknPopupLayouts::EMenuGraphicHeadingWindow );

    iPopup->SetTitleL( *iTitle );

    // Set up listbox

    iListBox->ConstructL( iPopup, EAknListBoxViewerFlags );

    // Create listbox model and give the model to the listbox

    iListModel = new( ELeave ) CDesCArraySeg( iGroupNames->Count( ) );

    // Create scroll indicator

    iListBox->CreateScrollBarFrameL( ETrue );

    iListBox->ScrollBarFrame( )->SetScrollBarVisibilityL(

                    CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    iListBox->Model( )->SetItemTextArray( iListModel );

    iListBox->Model( )->SetOwnershipType( ELbmDoesNotOwnItemArray );

    iListBox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::ExecuteL( )

    {

    // Show wait dialog

    iWaitDialog->RunLD( );

    // Start the scanning

    User::LeaveIfError(iEventReceiver->ScanL( iDrive ));

    // Get the result array

    iScanResults = iEventReceiver->ScanResultL( );

    // Set all results zero, so that no actual results are shown

    // before the scan is done.

    NullifyResults( );

    // Update the list with initial values (0's)

    RefreshL( );

    // Show popup

    iPopup->ExecuteLD( );

    iPopup = NULL; // Has to be set NULL because deleted in destructor

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::RefreshL( )

    {

    //TBuf< KListItemMaxLength > result;

    TBuf< KListItemMaxLength > unitText;

    TBuf< KListItemMaxLength > tempText;

    TPtrC unit;

    TInt64 res64( 0 );

    TInt count( iScanResults ? iScanResults->Count( ) : 0 );

    TInt maxGroupName(0);

    for( TInt i = 0; i < iGroupNames->Count(); i++ )

        {

        if( maxGroupName < ( *iGroupNames )[ i ].Length() )

            {

            maxGroupName = ( *iGroupNames )[ i ].Length();

            }

        }

    // Allocate memory for size, unit text and actual group name

    HBufC* result = HBufC::NewLC( maxGroupName + 2*KListItemMaxLength );

    TPtr resultPtr( result->Des() );

    HBufC* unitFormatter = StringLoader::LoadLC( R_UNIT_FORMATTER, &iCoeEnv );

    iListModel->Reset( );

    // Go through the result array and append to the model as text

    for( TInt i = 0; i < count; i++ )

        {

        res64 = ( *iScanResults )[ i ];

        unit.Set( iUtil->SolveUnitAndSize( res64 ) );

        StringLoader::Format( tempText, *unitFormatter, 0, I64INT( res64 ) );

        StringLoader::Format( unitText, tempText, 1, unit );

        resultPtr.Zero( );

        // The actual listbox row is constructed here

        // iListModel is just an array of descriptors

        if ( User::Language() == ELangArabic )

            {

            resultPtr.Append( KRightToLeftMark );

            }

        resultPtr.Append( unitText );

        resultPtr.Append( KMemListSeparator );

        if( i < iGroupNames->Count() )

            {

            resultPtr.Append( ( *iGroupNames )[ i ] );

            }

        else

            {

            resultPtr.Append( ( *iGroupNames )[ 0 ] );

            }

        iListModel->AppendL( resultPtr );

        }

    CleanupStack::PopAndDestroy( unitFormatter );

    CleanupStack::PopAndDestroy( result );

    // Update the listbox

    iListBox->HandleItemAdditionL( );

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::NullifyResults( )

    {

    // Set all results to zero

    if( iScanResults )

        {

        TInt count( iScanResults->Count( ) );

        for( TInt t = 0; t < count; t++ )

            {

            ( *iScanResults )[ t ] = 0;

            }

        }

    }

// ---------------------------------------------------------------------------

void CMemStatePopupImpl::OpenResourceAndReadArrayL( )

    {

    // Open dll resource

    TParse* fp = new(ELeave) TParse(); 

    fp->Set(KDirAndFile, &KDC_RESOURCE_FILES_DIR, NULL); 

    TFileName fileName( fp->FullName() );

    delete fp;

    BaflUtils::NearestLanguageFile( iCoeEnv.FsSession( ),

                                    fileName );

    iResLoader.OpenL( fileName );

    // Read localised unit texts from resource

    TResourceReader reader;

    iCoeEnv.CreateResourceReaderLC( reader, R_ARRAY_UNITS );

    CDesCArrayFlat* units = reader.ReadDesCArrayL( );

    CleanupStack::PushL( units );

    iUtil = CMSPUtil::NewL( units ); // Give the array to the util class

    CleanupStack::Pop( units );

    CleanupStack::PopAndDestroy(); // Private HBufC8* variable

                                   // of CreateResourceReaderLC()

    }

// --------------------------------------------------------------------------- 

void CMemStatePopupImpl::RunL()

    {

    TVolumeInfo volInfo;

    TInt err = iCoeEnv.FsSession().Volume( volInfo, iDrive );

    if(err != KErrNone)

        {

        iPopup->CancelPopup( );

        }

    else

        {

        StartObserver();

        }

    }

// --------------------------------------------------------------------------- 

void CMemStatePopupImpl::DoCancel()

    {

    iCoeEnv.FsSession().NotifyChangeCancel();

    }

// --------------------------------------------------------------------------- 

void CMemStatePopupImpl::StartObserver()

    {

    if ( IsActive() ) 

        {

        Cancel();

        }

    iCoeEnv.FsSession().NotifyChange( ENotifyDisk, iStatus );

    SetActive();

    }

// End of File