/*

* Copyright (c) 2009 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:

*

*/

#include <memspy/engine/memspyenginehelperfilesystem.h>

// System includes

#include <f32file.h>

// Driver includes

#include <memspy/driver/memspydriverclient.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyenginehelperchunk.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyengineoutputlist.h>

#include "MemSpyEngineOutputListItem.h"

// Remap of E32 constant since this value only exists in recent v9.3 builds and MemSpy needs to build on v9.1

const TUint KMemSpyDriveAttPageable = 0x100; // KDriveAttPageable

const TUint KMemSpyMediaAttPageable = 0x200; // KMediaAttPageable

// Literal constants

_LIT( KMemSpyVolumeLabelNotSet, "None" );

CMemSpyEngineHelperFileSystem::CMemSpyEngineHelperFileSystem( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

CMemSpyEngineHelperFileSystem::~CMemSpyEngineHelperFileSystem()

    {

    }

void CMemSpyEngineHelperFileSystem::ConstructL()

    {

    iFileServerProcessId = MemSpyEngineUtils::IdentifyFileServerProcessIdL();

    }

CMemSpyEngineHelperFileSystem* CMemSpyEngineHelperFileSystem::NewL( CMemSpyEngine& aEngine )

    {

    CMemSpyEngineHelperFileSystem* self = new(ELeave) CMemSpyEngineHelperFileSystem( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C CMemSpyEngineDriveList* CMemSpyEngineHelperFileSystem::DriveListL()

    {

    CMemSpyEngineDriveList* list = CMemSpyEngineDriveList::NewLC( iEngine.FsSession() );

    CleanupStack::Pop( list );

    return list;

    }

EXPORT_C TDriveNumber CMemSpyEngineHelperFileSystem::GetSystemDrive()

    {

    TDriveNumber ret = EDriveC;

#ifndef __WINS__

    const TInt KRFsGetSystemDriveOrdinal = 336;

    typedef TDriveNumber(*TRFsGetSystemDriveFunc)();

    //

    RLibrary lib;

    const TInt loadErr = lib.Load( _L("EFSRV.DLL") );

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineHelperFileSystem::GetSystemDrive() - dll load: %d", loadErr );

#endif

    if  ( loadErr == KErrNone )

        {

        TLibraryFunction ordinal = lib.Lookup( KRFsGetSystemDriveOrdinal );

#ifdef _DEBUG

        RDebug::Printf( "CMemSpyEngineHelperFileSystem::GetSystemDrive() - ordinal: 0x%08x", ordinal );

#endif

        //

        if  ( ordinal )

            {

            TRFsGetSystemDriveFunc func = (TRFsGetSystemDriveFunc) ordinal;

            ret = (*func)();

#ifdef _DEBUG

            RDebug::Printf( "CMemSpyEngineHelperFileSystem::GetSystemDrive() - drive: %c:\\", 'A' + ret);

#endif

            }

        //

        lib.Close();

        }

#endif

    //

    return ret;

    }

EXPORT_C void CMemSpyEngineHelperFileSystem::ListOpenFilesL()

    {

    TOpenFileScan scanner( iEngine.FsSession() );

    _LIT( KMemSpyContext, "Open File Listing" );

    _LIT( KMemSpyFolder, "OpenFiles" );

    iEngine.Sink().DataStreamBeginL( KMemSpyContext, KMemSpyFolder );

    _LIT(KHeading, "OPEN FILES");

    iEngine.Sink().OutputSectionHeadingL( KHeading, '=' );

    // Set prefix for overall listing

    _LIT(KOverallPrefix, "OpenFiles - ");

    iEngine.Sink().OutputPrefixSetLC( KOverallPrefix );

    CFileList* list = NULL;

    scanner.NextL( list );

    while( list != NULL )

        {

        CleanupStack::PushL( list );

        ListOpenFilesL( *list, scanner.ThreadId() );

        CleanupStack::PopAndDestroy( list );

        //

        list = NULL;

        scanner.NextL( list );

        }

    CleanupStack::PopAndDestroy(); // prefix

    iEngine.Sink().DataStreamEndL();

    }

EXPORT_C void CMemSpyEngineHelperFileSystem::ListOpenFilesL( const TThreadId& aThreadId )

    {

    TOpenFileScan scanner( iEngine.FsSession() );

    _LIT( KMemSpyContext, "Open File Listing" );

    _LIT( KMemSpyFolder, "OpenFiles" );

    iEngine.Sink().DataStreamBeginL( KMemSpyContext, KMemSpyFolder );

    _LIT(KHeading, "OPEN FILES");

    iEngine.Sink().OutputSectionHeadingL( KHeading, '=' );

    // Set prefix for overall listing

    _LIT(KOverallPrefix, "OpenFiles - ");

    iEngine.Sink().OutputPrefixSetLC( KOverallPrefix );

    CFileList* list = NULL;

    scanner.NextL( list );

    while( list != NULL )

        {

        if  ( scanner.ThreadId() == aThreadId )

            {

            CleanupStack::PushL( list );

            ListOpenFilesL( *list, scanner.ThreadId() );

            CleanupStack::Pop( list );

            }

        //

        delete list;

        list = NULL;

        scanner.NextL( list );

        }

    CleanupStack::PopAndDestroy(); // prefix

    iEngine.Sink().DataStreamEndL();

    }

void CMemSpyEngineHelperFileSystem::GetDriveNumberText( TDriveNumber aDriveNumber, TDes& aText )

    {

    const TInt offset = aDriveNumber - EDriveA;

    const TChar driveChar = 'A' + offset;

    aText.Copy( _L("EDrive") );

    aText.Append( driveChar );

    }

void CMemSpyEngineHelperFileSystem::ListOpenFilesL( const CFileList& aList, const TThreadId& aThreadId )

    {

    _LIT( KLineFormatSpec, "%d %S %S %S %S" );

    TBuf<64> timeBuf;

    TMemSpySizeText valueBuf;

    HBufC* itemBuf = HBufC::NewLC( 3 * KMaxFullName );

    TPtr item( itemBuf->Des() );

    TFullName threadName;

    RThread thread;

    if  ( iEngine.Driver().OpenThread( aThreadId, thread ) == KErrNone )

        {

        threadName = thread.FullName();

        thread.Close();

        }

    const TInt entryCount = aList.Count();

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

        {

        const TEntry& entry = aList[ i ];

        // Get time and size format strings

        valueBuf = MemSpyEngineUtils::FormatSizeText( entry.iSize );

        MemSpyEngineUtils::FormatTimeL( timeBuf, entry.iModified );

        // Create item 

        item.Format( KLineFormatSpec, 0, &entry.iName, &valueBuf, &timeBuf, &threadName );

        iEngine.Sink().OutputLineL( item );

        }

    CleanupStack::PopAndDestroy( itemBuf );

    }

CMemSpyEngineOpenFileList* CMemSpyEngineHelperFileSystem::ListOpenFilesLC()

    {

    CMemSpyEngineOpenFileList* list = CMemSpyEngineOpenFileList::NewLC( iEngine );

    return list;

    }

TProcessId CMemSpyEngineHelperFileSystem::FileServerProcessId() const

    {

    return iFileServerProcessId;

    }

const CMemSpyEngineChunkEntry* CMemSpyEngineHelperFileSystem::IdentifyCacheChunk( const CMemSpyEngineChunkList& aList, TInt& aIndex ) const

    {

    aIndex = KErrNotFound;

    const CMemSpyEngineChunkEntry* ret = NULL;

    //

    const TInt count = aList.Count();

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

        {

        const CMemSpyEngineChunkEntry& entry = aList.At( i );

        const TMemSpyDriverChunkInfo& info = entry.Info();

        //

        if  ( info.iType == EMemSpyDriverChunkTypeLocal )

            {

#ifdef _DEBUG

            RDebug::Print( _L("CMemSpyEngineHelperFileSystem::IdentifyCacheChunk() - name: %S, pid: 0x%04x, f32Pid: 0x%04x, size: %d, max: %d, attribs: %d"), &info.iName, info.iOwnerId, (TUint) iFileServerProcessId, info.iSize, info.iMaxSize, info.iAttributes );

#endif

            if ( info.iOwnerId == FileServerProcessId() )

                {

                // Additionally, the chunk is disconnected.

                const TBool isDisconnected = ( info.iAttributes & EMemSpyChunkAttributesDisconnected );

#ifdef _DEBUG

                RDebug::Printf( "CMemSpyEngineHelperFileSystem::IdentifyCacheChunk() - it is an f32 local chunk... isDisconnected: %d", isDisconnected );

#endif

                if  ( info.iSize > 0 && info.iMaxSize > 0 && isDisconnected )

                    {

                    aIndex = i;

                    ret = &entry;

#ifdef _DEBUG

                    RDebug::Print( _L("CMemSpyEngineHelperFileSystem::IdentifyCacheChunk() - FOUND: %S, size: %d"), &info.iName, info.iSize );

#endif

                    break;

                    }

                }

            }

        }

    //

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineHelperFileSystem::IdentifyCacheChunk() - END - ret: 0x%08x", ret );

#endif

    return ret;

    }

CMemSpyEngineDriveList::CMemSpyEngineDriveList( RFs& aFsSession )

:   CActive( EPriorityStandard ), iFsSession( aFsSession )

    {

    CActiveScheduler::Add( this );

    }

EXPORT_C CMemSpyEngineDriveList::~CMemSpyEngineDriveList()

    {

    Cancel();

    //

    iItems.ResetAndDestroy();

    iItems.Close();

    }

void CMemSpyEngineDriveList::ConstructL()

    {

    TDriveList drives;

    if  ( iFsSession.DriveList( drives ) == KErrNone )

        {

        for( TInt i=EDriveA; i<=EDriveZ; i++ )

            {

            const TDriveNumber drive = static_cast< TDriveNumber >( i );

            if  ( drives[ i ] != KDriveAbsent )

                {

                TRAP_IGNORE( 

                    CMemSpyEngineDriveEntry* driveEntry = CMemSpyEngineDriveEntry::NewLC( *this, drive );

                    iItems.AppendL( driveEntry );

                    CleanupStack::Pop( driveEntry );

                    );

                }

            }

        }

    iFsSession.NotifyChange( ENotifyDisk, iStatus );

    SetActive();

    }

CMemSpyEngineDriveList* CMemSpyEngineDriveList::NewLC( RFs& aFsSession )

    {

    CMemSpyEngineDriveList* self = new(ELeave) CMemSpyEngineDriveList( aFsSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

void CMemSpyEngineDriveList::RunL()

    {

    iFsSession.NotifyChange( ENotifyDisk, iStatus );

    SetActive();

    //

    NotifyListChangedL();

    }

void CMemSpyEngineDriveList::DoCancel()

    {

    iFsSession.NotifyChangeCancel();

    }

EXPORT_C void CMemSpyEngineDriveList::SetObserver( MMemSpyEngineDriveListObserver* aObserver )

    {

    iObserver = aObserver;

    }

EXPORT_C TInt CMemSpyEngineDriveList::Count() const

    {

    return iItems.Count();

    }

EXPORT_C CMemSpyEngineDriveEntry& CMemSpyEngineDriveList::At( TInt aIndex )

    {

    return *iItems[ aIndex ];

    }

EXPORT_C const CMemSpyEngineDriveEntry& CMemSpyEngineDriveList::At( TInt aIndex ) const

    {

    return *iItems[ aIndex ];

    }

EXPORT_C TInt CMemSpyEngineDriveList::ItemIndex( const CMemSpyEngineDriveEntry& aEntry ) const

    {

    TInt ret = KErrNotFound;

    //

    const TInt count = Count();

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

        {

        const CMemSpyEngineDriveEntry* item = iItems[ i ];

        //

        if  ( item == &aEntry )

            {

            ret = i;

            break;

            }

        }

    //

    return ret;

    }

EXPORT_C CMemSpyEngineDriveEntry* CMemSpyEngineDriveList::EntryByDriveNumber( TDriveNumber aDrive )

    {

    CMemSpyEngineDriveEntry* ret = NULL;

    //

    const TInt count = Count();

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

        {

        CMemSpyEngineDriveEntry* item = iItems[ i ];

        //

        if  ( item->DriveNumber() == aDrive )

            {

            ret = item;

            break;

            }

        }

    //

    return ret;

    }

RFs& CMemSpyEngineDriveList::FsSession()

    {

    return iFsSession;

    }

void CMemSpyEngineDriveList::NotifyListChangedL()

    {

    if  ( iObserver != NULL )

        {

        TRAP_IGNORE( iObserver->HandleDriveListChangedL( *this ) );

        }

    }

EXPORT_C TInt CMemSpyEngineDriveList::MdcaCount() const

    {

    return Count();

    }

EXPORT_C TPtrC CMemSpyEngineDriveList::MdcaPoint( TInt aIndex ) const

    {

    const CMemSpyEngineDriveEntry& item = At( aIndex );

    return TPtrC( item.Caption() );

    }

CMemSpyEngineDriveEntry::CMemSpyEngineDriveEntry( CMemSpyEngineDriveList& aList, TDriveNumber aDriveNumber )

:   CActive( CActive::EPriorityStandard), iList( aList ), iDriveNumber( aDriveNumber ), iDriveUnit( aDriveNumber )

    {

    CActiveScheduler::Add( this );

    }

EXPORT_C CMemSpyEngineDriveEntry::~CMemSpyEngineDriveEntry()

    {

    Cancel();

    //

    delete iCaption;

    delete iItems;

    }

void CMemSpyEngineDriveEntry::ConstructL()

    {

    RunL();

    }

EXPORT_C void CMemSpyEngineDriveEntry::SetObserver( MMemSpyEngineDriveEntryObserver* aObserver )

    {

    iObserver = aObserver;

    }

void CMemSpyEngineDriveEntry::RefreshL()

    {

    CMemSpyEngineOutputList* items = CMemSpyEngineOutputList::NewL();

    delete iItems;

    iItems = items;

    /*

	RFs13VolumeIOParamEiR18TVolumeIOParamInfo @ 344 NONAME

	RFs17FileSystemSubTypeEiR6TDes16 @ 345 NONAME

	RFs18QueryVolumeInfoExtEi22TQueryVolumeInfoExtCmdR5TDes8 @ 346 NONAME

    */

    const TInt err1 = FsSession().Drive( iDriveInfo, iDriveNumber );

    const TInt err2 = FsSession().Volume( iVolumeInfo, iDriveNumber );

    if  ( err1 || err2 )

        {

        _LIT( KUnavailable, "Unavailable");

        iItems->AddItemL( KUnavailable );

        // Mostly empty caption

        CreateCaptionL( KNullDesC, KNullDesC );

        }

    else

        {

        // Literal constants

        TBuf<KMaxFileName * 2> temp;

        TBuf<KMaxFileName * 2> item;