/*

* Copyright (c) 2002-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:  Recogniser wrapper

*

*/

// INCLUDE FILES

#include "CGflmFileRecognizer.h"

#include "CGflmDriveResolver.h"

#include "CGflmDriveItem.h"

#include "GflmUtils.h"

#include "GFLMConsts.h"

#include <e32svr.h>

#include <barsread.h>

#include <GflmFileExtensionMimeTypes.rsg>

#include <data_caging_path_literals.hrh> 

// CONSTANTS

_LIT( KFileExtensionResourceFile, "gflmfileextensionmimetypes.rsc" );

const TInt KMimeTypeGranularity = 10;

const TUint KPerCentToDrop = 30;

const TUint KHundredPerCent = 100;

// ============================ MEMBER FUNCTIONS ===============================

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

// CGflmFileRecognizer::CGflmFileRecognizer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CGflmFileRecognizer::CGflmFileRecognizer(

        CGflmDriveResolver* aDriveResolver,

        RFs& aFs ) :

    iCache( _FOFF( CPathTypePair, iLink ) ),

    iDriveResolver( aDriveResolver ),

    iFs( aFs )

    {

    }

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

// CGflmFileRecognizer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CGflmFileRecognizer::ConstructL( TInt aMemoryConsumption )

    {

    User::LeaveIfError( iApaSession.Connect() );

    iMimeTypes = new( ELeave ) CDesCArraySeg( KMimeTypeGranularity );

    iCacheMaxMemoryUsage = aMemoryConsumption;

    // Get resource drive from dll location

    TFileName dllFileName;

    Dll::FileName( dllFileName );

    TParsePtrC dllParse( dllFileName );

    TFileName resFileName;

    resFileName.Copy( dllParse.Drive() );

    resFileName.Append( KDC_RESOURCE_FILES_DIR );

    GflmUtils::EnsureFinalBackslash( resFileName );

    resFileName.Append( KFileExtensionResourceFile );

    RResourceFile resFile;

    resFile.OpenL( iFs, resFileName );

    CleanupClosePushL( resFile );

    resFile.ConfirmSignatureL();

    ConstructExtMimePairsL( resFile, R_EXT_MIME_PAIRS, iExtMimePairs );

    ConstructExtMimePairsL(

        resFile, R_REMOTE_EXT_MIME_PAIRS, iRemoteExtMimePairs );

    CleanupStack::PopAndDestroy( &resFile );

    }

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

// CGflmFileRecognizer::ConstructExtMimePairsL

//

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

//

void CGflmFileRecognizer::ConstructExtMimePairsL(

        RResourceFile& aResFile,

        TInt aResId,

        RPointerArray< CExtMimePair >& aPairs )

    // read the pairs

    HBufC8* resData = aResFile.AllocReadLC( aResId );

    TResourceReader reader;

    reader.SetBuffer( resData );

    TInt count( reader.ReadInt16() );

    aPairs.ReserveL( count );

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

        {

        TPtrC ext( reader.ReadTPtrC() );

        TPtrC mime( reader.ReadTPtrC() );

        CExtMimePair* pair = new (ELeave) CExtMimePair();

        CleanupStack::PushL( pair );

        pair->iExt = ext.AllocL();

        pair->iMime = mime.AllocL();

        aPairs.AppendL( pair );

        CleanupStack::Pop( pair );

        }

    CleanupStack::PopAndDestroy( resData );

    }

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

// CGflmFileRecognizer::FindMimeFromExt

//

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

//

TPtrC CGflmFileRecognizer::FindMimeFromExt(

        const TDesC& aExt,

        RPointerArray< CExtMimePair >& aPairs )

    {

    TInt count( aPairs.Count() );

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

        {

        CExtMimePair* pair = aPairs[ i ];

        if( !aExt.CompareF( *pair->iExt ) )

            {

            return TPtrC( *pair->iMime );

            }

        }

    return TPtrC( KNullDesC );

    }

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

// CGflmFileRecognizer::NewL

// Two-phased constructor.

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

//

CGflmFileRecognizer* CGflmFileRecognizer::NewL(

        RFs& aFs,

        TInt aMemoryConsumption,

        CGflmDriveResolver* aDriveResolver )

    {

    CGflmFileRecognizer* self =

        new( ELeave ) CGflmFileRecognizer( aDriveResolver, aFs );

    CleanupStack::PushL( self );

    self->ConstructL( aMemoryConsumption );

    CleanupStack::Pop( self );

    return self;

    }

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

// CGflmFileRecognizer::~CGflmFileRecognizer

//

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

//

CGflmFileRecognizer::~CGflmFileRecognizer()

    {

    iApaSession.Close();

    FlushCache();

    delete iMimeTypes;

    iExtMimePairs.ResetAndDestroy();

    iExtMimePairs.Close();

    iRemoteExtMimePairs.ResetAndDestroy();

    iRemoteExtMimePairs.Close();

    }

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

// CGflmFileRecognizer::RecognizeL( const TDesC& aFilename )

// (other items were commented in a header).

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

//

TPtrC CGflmFileRecognizer::RecognizeL( const TDesC& aFilename )

    {

    TPtrC mimeType;

    TRAPD( err, mimeType.Set( DoRecognizeL( aFilename ) ) );

    if ( err == KErrNoMemory )

        {

        FlushCache();

        return DoRecognizeL( aFilename );

        }

    User::LeaveIfError( err );

    return mimeType;

    }

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

// CGflmFileRecognizer::DoRecognizeL( const TDesC& aFilename )

// (other items were commented in a header).

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

//

TPtrC CGflmFileRecognizer::DoRecognizeL( const TDesC& aFilename )

    {

    // Search the cache for a hit

    TInt cropPoint( aFilename.LocateReverse( KGFLMDot()[ 0 ] ) );

    TBool isRemoteDrive( EFalse );

    if ( iDriveResolver && iDriveResolver->IsRemoteDrive( aFilename ) )

        {

        isRemoteDrive = ETrue;

        }

    if( cropPoint != KErrNotFound )

        {        

        TPtrC ext( aFilename.Mid( cropPoint ) );

        TPtrC mime( FindMimeFromExt( ext, iExtMimePairs ) );

        if ( mime.Length() )

            {

            return mime;

            }

        // Use remote drive specific extension mime pairs and skip

        // content recognition because it is so slow for remote drives.

        // Mime types are resolved from extension by remote storage framework

        // anyway.

        if ( isRemoteDrive)

            {

            return FindMimeFromExt( ext, iRemoteExtMimePairs );

            }

        }

    else if ( isRemoteDrive)

        {

        // Skip content recognition for remote drives because it is so slow

        return TPtrC( KNullDesC );

        }

    TDblQueIter< CPathTypePair > pairIt( iCache );

    pairIt.SetToFirst();

    CPathTypePair* pair = NULL;

    while ( ( pair = pairIt++ ) != NULL )

        {

        TPtrC ptr( *( pair->iFilename ) );

        if( ptr.Length() == aFilename.Length() &&

           !aFilename.CompareF( ptr ) )

            {

            // Cache hit

            // Move item to the first position if not already.

            // When clearing cache, oldest items can be dropped easily.

            pair->iLink.Deque();

            iCache.AddFirst( *pair );

            if ( pair->iTypeIndex != KErrNotFound )

                {

                return iMimeTypes->MdcaPoint( pair->iTypeIndex );

                }

            return TPtrC( KNullDesC );

            }

        }

        // Cache miss

        TUid uid( KNullUid );

        TDataType datatype;

        TIMESTAMP( "GFLM AppForDocument started: " )

        // Acquire the mime-type of the file

        TInt err( iApaSession.AppForDocument( aFilename, uid, datatype ) );

        TIMESTAMP( "GFLM AppForDocument ended: " )

        if ( err != KErrNone )

            {

            // If recognition returns error, handle as unrecognized file

            ERROR_LOG1(

                "CGflmFileRecognizer::DoRecognizeL-AppForDocument=%d",

                err )

            return TPtrC( KNullDesC );

            }

        CPathTypePair* newPair = CPathTypePair::NewLC( aFilename );

        TPtrC mimeType( datatype.Des() );

        INFO_LOG2( "GFLM AppForDocument:file=%S,mime=%S", &aFilename, &mimeType )

        // Run through the mime-type list to find the correct index

        if ( mimeType.Length() )

            {

            TBool isMimeFound( EFalse );

            TInt mimeCount( iMimeTypes->MdcaCount() );

            for ( TInt j( 0 ); j < mimeCount; j++ )

                {

                if( !mimeType.CompareF( iMimeTypes->MdcaPoint( j ) ) )

                    {

                    newPair->iTypeIndex = j;

                    isMimeFound = ETrue;

                    break;

                    }

                }

            // Add mime type to list if not already added

            if ( !isMimeFound )

                {

                iMimeTypes->AppendL( mimeType );

                newPair->iTypeIndex = mimeCount;

                }

            }

        // Cleanup cache and add new pair

        CleanupStack::Pop( newPair );

        CleanupCache();

        iCacheMemoryUsage += newPair->Size();

        iCache.AddFirst( *newPair );

        if ( newPair->iTypeIndex != KErrNotFound )

            {

            return iMimeTypes->MdcaPoint( newPair->iTypeIndex );

            }

        return TPtrC( KNullDesC );

    }

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

// CGflmFileRecognizer::FlushCache( )

//

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

//

void CGflmFileRecognizer::FlushCache()

    {

    TDblQueIter< CPathTypePair > pairIt( iCache );

    pairIt.SetToFirst();

    CPathTypePair* pair = NULL;

    while ( ( pair = pairIt++ ) != NULL )

        {

        pair->iLink.Deque();

        delete pair;

        }

    iCacheMemoryUsage = 0;

    }

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

// CGflmFileRecognizer::CleanupCache( )

//

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

//

void CGflmFileRecognizer::CleanupCache( )

    {

    if( iCacheMemoryUsage > iCacheMaxMemoryUsage )

        {

        TInt dropThreshold = ( TInt ) ( ( ( ( TUint ) iCacheMaxMemoryUsage ) *

            KPerCentToDrop ) / KHundredPerCent );

        TInt droppedSize( 0 );

        TDblQueIter< CPathTypePair > pairIt( iCache );

        pairIt.SetToLast();

        CPathTypePair* pair = NULL;

        while ( ( pair = pairIt-- ) != NULL )

            {

            droppedSize += pair->Size();

            pair->iLink.Deque();

            delete pair;

            if ( droppedSize >= dropThreshold )

                {

                break;

                }

            }

        iCacheMemoryUsage -= droppedSize;

        }

    }

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

// CGflmFileRecognizer::CPathTypePair::NewLC()

// 

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

//

CGflmFileRecognizer::CPathTypePair*

        CGflmFileRecognizer::CPathTypePair::NewLC( const TDesC& aFilename )

    {

    CPathTypePair* self = new ( ELeave ) CPathTypePair();

    CleanupStack::PushL( self );

    self->ConstructL( aFilename );

    return self;

    }

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

// CGflmFileRecognizer::CPathTypePair::ConstructL()

// 

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

//

void CGflmFileRecognizer::CPathTypePair::ConstructL( const TDesC& aFilename )

    {

    iFilename = aFilename.AllocL();

    }

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

// CGflmFileRecognizer::CPathTypePair::CPathTypePair()

// 

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

//

CGflmFileRecognizer::CPathTypePair::CPathTypePair() :

        iTypeIndex( KErrNotFound )

    {

    }

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

// CGflmFileRecognizer::CPathTypePair::~CPathTypePair()

// 

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

//

CGflmFileRecognizer::CPathTypePair::~CPathTypePair()

    {

    delete iFilename;

    }

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

// CGflmFileRecognizer::CPathTypePair::Size()

// 

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

//

TInt CGflmFileRecognizer::CPathTypePair::Size() const

    {

    return ( sizeof( TInt ) + iFilename->Size() + sizeof( TDblQueLink ) );

    }

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

// CGflmFileRecognizer::CExtMimePair::~CExtMimePair()

// 

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

//

CGflmFileRecognizer::CExtMimePair::~CExtMimePair()

    {

    delete iExt;

    delete iMime;

    }

//  End of File