/*

* Copyright (c) 2008-2010 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:   Recognizes files to get corresponding MIME types

*

*/

#include "appmngr2filerecognizer.h"     // CAppMngr2FileRecognizer

#include <appmngr2recognizedfile.h>     // CAppMngr2RecognizedFile

#include <f32file.h>                    // RFs, CDir

#include <apmstd.h>                     // TDataType

#include <caf/caf.h>                    // ContentAccess

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

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

// CAppMngr2FileRecognizer::NewL()

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

//

CAppMngr2FileRecognizer* CAppMngr2FileRecognizer::NewL( RFs& aFs )

    {

    CAppMngr2FileRecognizer* self = new (ELeave) CAppMngr2FileRecognizer( aFs );

    return self;

    }

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

// CAppMngr2FileRecognizer::~CAppMngr2FileRecognizer()

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

//

CAppMngr2FileRecognizer::~CAppMngr2FileRecognizer()

    {

    Cancel();

    iDirStatus = NULL;

    delete iDirPath;

    delete iDirEntries;

    iResultArray.ResetAndDestroy();

    }

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

// CAppMngr2FileRecognizer::RecognizeFilesL()

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

//

void CAppMngr2FileRecognizer::RecognizeFilesL( const TDesC& aPath,

        TRequestStatus& aStatus )

    {

    if( IsActive() )

        {

        User::Leave( KErrInUse );

        }

    if( iDirPath )

        {

        delete iDirPath;

        iDirPath = NULL;

        }

    iDirPath = aPath.AllocL();

    if( iDirEntries )

        {

        delete iDirEntries;

        iDirEntries = NULL;

        }

    TInt err = iFs.GetDir( *iDirPath, KEntryAttNormal, ESortNone, iDirEntries );

    User::LeaveIfError( err );

    aStatus = KRequestPending;  // for recognizing all files in the directory

    iDirStatus = &aStatus;

    iResultArray.ResetAndDestroy();

    iIndex = 0;

    iState = ERecognizing;

    // start recognizing the first file asynchronously

    SetActive();

    TRequestStatus* fileStatus = &iStatus;

    User::RequestComplete( fileStatus, KErrNone );

    }

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

// CAppMngr2FileRecognizer::CancelRecognizeFiles()

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

//

void CAppMngr2FileRecognizer::CancelRecognizeFiles()

    {

    Cancel();

    }

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

// CAppMngr2FileRecognizer::Results()

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

//

RPointerArray<CAppMngr2RecognizedFile>& CAppMngr2FileRecognizer::Results()

    {

    return iResultArray;

    }

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

// CAppMngr2FileRecognizer::DoCancel()

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

//

void CAppMngr2FileRecognizer::DoCancel()

    {

    switch( iState )

        {

        case EIdle:

            break;

        case ERecognizing:

            iState = EIdle;

            if( iDirStatus )

                {

                User::RequestComplete( iDirStatus, KErrCancel );

                iDirStatus = NULL;

                }

            break;

        default:

            break;

        }

    }

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

// CAppMngr2FileRecognizer::RunL()

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

//

void CAppMngr2FileRecognizer::RunL()

    {

    User::LeaveIfError( iStatus.Int() );

    switch( iState )

        {

        case EIdle:

            break;

        case ERecognizing:

            RecognizeNextFileL();

            break;

        default:

            break;

        }

    }

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

// CAppMngr2FileRecognizer::RunError()

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

//

TInt CAppMngr2FileRecognizer::RunError( TInt aError )

    {

    // RunL() leaved, pass the error code to caller

    if( iDirStatus )

        {

        User::RequestComplete( iDirStatus, aError );

        iDirStatus = NULL;

        }

    return KErrNone;

    }

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

// CAppMngr2FileRecognizer::CAppMngr2FileRecognizer()

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

//

CAppMngr2FileRecognizer::CAppMngr2FileRecognizer( RFs& aFs ) :

        CActive( CActive::EPriorityLow ), iFs( aFs )

    {

    // EPriorityLow used for smooth operation. Low priority allows UI refreshes

    // to proceed when some files have been recognized (even if there are still

    // more files to be recognized and recognizer is waiting for the next file

    // to be recognized).

    CActiveScheduler::Add( this );

    }

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

// CAppMngr2FileRecognizer::RecognizeNextFileL()

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

//

void CAppMngr2FileRecognizer::RecognizeNextFileL()

    {

    if( iIndex < iDirEntries->Count() )

        {

        // recognize the file which index is iIndex

        const TEntry& file = ( *iDirEntries )[ iIndex ];

        HBufC* fullName = HBufC::NewLC( iDirPath->Length() + file.iName.Length() );

        TPtr namePtr( fullName->Des() );

        namePtr.Copy( *iDirPath );

        namePtr.Append( file.iName );

        ContentAccess::CContent* content = ContentAccess::CContent::NewLC(

                *fullName, ContentAccess::EContentShareReadWrite );

        HBufC* mimeType = HBufC::NewLC( KMaxDataTypeLength );

        TPtr mimePtr( mimeType->Des() );

        User::LeaveIfError( content->GetStringAttribute( ContentAccess::EMimeType, mimePtr ) );

        CAppMngr2RecognizedFile* recFile = CAppMngr2RecognizedFile::NewL( fullName, mimeType );

        CleanupStack::Pop( mimeType );		// CAppMngr2RecognizedFile takes ownership

        CleanupStack::PopAndDestroy( content );

        CleanupStack::Pop( fullName );

        CleanupStack::PushL( recFile );

        iResultArray.AppendL( recFile );

        CleanupStack::Pop( recFile );

        // and then recognize the next file

        iIndex++;

        SetActive();

        TRequestStatus* fileStatus = &iStatus;

        User::RequestComplete( fileStatus, KErrNone );

        }

    else

        {

        // all done, directory has been processed

        User::RequestComplete( iDirStatus, KErrNone );

        iDirStatus = NULL;

        }

    }