/*

* Copyright (c) 2006-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:  Background thread functionality wrapper

*

*/

// INCLUDE FILES

#include "CFileManagerThreadWrapper.h"

#include "FileManagerDebug.h"

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

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

// CFileManagerThreadWrapper::CFileManagerThreadWrapper()

//

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

CFileManagerThreadWrapper::CFileManagerThreadWrapper() :

    CActive( CActive::EPriorityStandard )

    {

    }

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

// CFileManagerThreadWrapper::~CFileManagerThreadWrapper()

//

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

CFileManagerThreadWrapper::~CFileManagerThreadWrapper()

    {

    Cancel();

    delete iNotifyObserver;

    iSemaphore.Close();

    }

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

// CFileManagerThreadWrapper::NewL()

//

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

CFileManagerThreadWrapper* CFileManagerThreadWrapper::NewL()

    {

    CFileManagerThreadWrapper* self =

        new (ELeave) CFileManagerThreadWrapper();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CFileManagerThreadWrapper::ConstructL()

//

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

void CFileManagerThreadWrapper::ConstructL()

    {

    CActiveScheduler::Add( this );

    User::LeaveIfError( iSemaphore.CreateLocal( 0 ) );

    iNotifyObserver = CNotifyObserver::NewL( *this );

    }

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

// CFileManagerThreadWrapper::RunL()

//

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

void CFileManagerThreadWrapper::RunL()

    {

    iNotifyObserver->Cancel();

    TInt err( iStatus.Int() );

    LOG_IF_ERROR1( err, "CFileManagerThreadWrapper::RunL()-err=%d", err )

    if ( iNotify & MFileManagerThreadFunction::ENotifyFinished )

        {

        TRAP_IGNORE( iFunction->NotifyThreadClientL(

            MFileManagerThreadFunction::ENotifyFinished, err ) );

        }

    }

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

// CFileManagerThreadWrapper::DoNotifyL()

//

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

void CFileManagerThreadWrapper::DoNotifyL( TInt aErr )

    {

    LOG_IF_ERROR1( aErr, "CFileManagerThreadWrapper::DoNotifyL()-aErr=%d", aErr )

    iResumePending = ETrue;

    if ( aErr != KErrNone &&

        ( iNotify & MFileManagerThreadFunction::ENotifyError ) )

        {

        iFunction->NotifyThreadClientL(

            MFileManagerThreadFunction::ENotifyError, aErr );

        }

    else if ( iNotify & MFileManagerThreadFunction::ENotifyStepFinished )

        {

        iFunction->NotifyThreadClientL(

            MFileManagerThreadFunction::ENotifyStepFinished, aErr );

        }

    }

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

// CFileManagerThreadWrapper::RunError()

//

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

TInt CFileManagerThreadWrapper::RunError( TInt aErr )

    {

    if ( aErr != KErrNone )

        {

        ERROR_LOG1( "CFileManagerThreadWrapper::RunError()-err=%d", aErr )

        iCancel = ETrue;

        ResumeThread();

        }

    return aErr;

    }

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

// CFileManagerThreadWrapper::DoCancel()

//

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

void CFileManagerThreadWrapper::DoCancel()

    {

    FUNC_LOG

    CancelThread();

    iSemaphore.Signal(); // To avoid deadlock

    }

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

// CFileManagerThreadWrapper::StartThread()

//

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

TInt CFileManagerThreadWrapper::StartThread(

        MFileManagerThreadFunction& aFunction,

        TUint aNotify,

        TThreadPriority aPriority )

    {

    FUNC_LOG

    TInt err( KErrAlreadyExists );

    if ( !IsActive() )

        {

        RThread thread;

        err = thread.Create(

            KNullDesC, ThreadFunction, KDefaultStackSize, NULL, this );

        if ( err == KErrNone )

            {

            thread.SetPriority( aPriority );

            thread.Logon( iStatus );

            iClientId = RThread().Id();

            iFunction = &aFunction;

            iNotify = aNotify;

            iCancel = EFalse;

            iNotifyObserver->Activate();

            SetActive();

            thread.Resume();

            thread.Close();

            }

        }

    LOG_IF_ERROR1( err, "CFileManagerThreadWrapper::StartThread()-err=%d",

        err )

    return err;

    }

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

// CFileManagerThreadWrapper::ThreadFunction()

//

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

TInt CFileManagerThreadWrapper::ThreadFunction( TAny* ptr )

    {

    FUNC_LOG

    CFileManagerThreadWrapper* self =

        static_cast< CFileManagerThreadWrapper* >( ptr );

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if ( !cleanupStack )

        {

        return KErrNoMemory;

        }

    TRAPD( err, self->ThreadFunctionL() );

    self->iFunction->ReleaseThread();

    delete cleanupStack;

    return err;

    }

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

// CFileManagerThreadWrapper::ThreadFunctionL()

//

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

void CFileManagerThreadWrapper::ThreadFunctionL()

    {

    FUNC_LOG

    iFunction->InitThreadL();

    while ( !iCancel )

        {

        TRAPD( err, iFunction->ThreadStepL() );

        if ( !iCancel )

            {

            if ( err != KErrNone &&

                ( iNotify & MFileManagerThreadFunction::ENotifyError ) )

                {

                User::LeaveIfError( NotifyClientAndWaitConfirm( err ) );

                }

            else if ( iNotify &

                MFileManagerThreadFunction::ENotifyStepFinished )

                {

                User::LeaveIfError( NotifyClientAndWaitConfirm( err ) );

                }

            else

                {

                User::LeaveIfError( err );

                }

            }

        if ( iFunction->IsThreadDone() )

            {

            break;

            }

        }

    if ( iCancel )

        {

        User::LeaveIfError( KErrCancel );

        }

    }

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

// CFileManagerThreadWrapper::CancelThread()

//

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

void CFileManagerThreadWrapper::CancelThread()

    {

    FUNC_LOG

    iCancel = ETrue;

    }

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

// CFileManagerThreadWrapper::IsThreadCanceled()

//

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

TBool CFileManagerThreadWrapper::IsThreadCanceled() const

    {

    return iCancel;

    }

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

// CFileManagerThreadWrapper::NotifyClientAndWaitConfirm()

//

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

TInt CFileManagerThreadWrapper::NotifyClientAndWaitConfirm( TInt aErr )

    {

    FUNC_LOG

    RThread client;

    TInt err( client.Open( iClientId ) );

    if ( err == KErrNone )

        {

        iNotifyObserver->Complete( client, aErr );

        client.Close();

        iSemaphore.Wait(); // Wait resume from client

        }

    return err;

    }

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

// CFileManagerThreadWrapper::ResumeThread()

//

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

void CFileManagerThreadWrapper::ResumeThread()

    {

    FUNC_LOG

    if ( !iNotifyObserver->IsActive() && iResumePending )

        {

        iResumePending = EFalse;

        iNotifyObserver->Activate();

        iSemaphore.Signal(); // Resume thread stepping

        }

    }

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

// CFileManagerThreadWrapper::IsThreadStarted()

//

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

TBool CFileManagerThreadWrapper::IsThreadStarted() const

    {

    return IsActive();

    }

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

// CFileManagerThreadWrapper::CNotifyObserver::CNotifyObserver()

//

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

CFileManagerThreadWrapper::CNotifyObserver::CNotifyObserver(

    CFileManagerThreadWrapper& aWrapper ) :

        CActive( CActive::EPriorityStandard ),

        iWrapper( aWrapper )

    {

    }

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

// CFileManagerThreadWrapper::CNotifyObserver::NewL()

//

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

CFileManagerThreadWrapper::CNotifyObserver*

    CFileManagerThreadWrapper::CNotifyObserver::NewL(

        CFileManagerThreadWrapper& aWrapper )

    {

    CNotifyObserver* self = new (ELeave) CNotifyObserver( aWrapper );

    CActiveScheduler::Add( self );

    return self;

    }

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

// CFileManagerThreadWrapper::CNotifyObserver::~CNotifyObserver()

//

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

CFileManagerThreadWrapper::CNotifyObserver::~CNotifyObserver()

    {

    Cancel();

    }

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

// CFileManagerThreadWrapper::CNotifyObserver::RunL()

//

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

void CFileManagerThreadWrapper::CNotifyObserver::RunL()

    {

    iWrapper.DoNotifyL( iStatus.Int() );

    }

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

// CFileManagerThreadWrapper::CNotifyObserver::RunError()

//

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

TInt CFileManagerThreadWrapper::CNotifyObserver::RunError( TInt aErr )

    {

    return iWrapper.RunError( aErr );

    }

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

// CFileManagerThreadWrapper::CNotifyObserver::DoCancel()

//

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

void CFileManagerThreadWrapper::CNotifyObserver::DoCancel()

    {

    // Just complete status immediately since

    // background thread does not complete status anymore

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrCancel );

    }

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

// CFileManagerThreadWrapper::CNotifyObserver::Activate()

//

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

void CFileManagerThreadWrapper::CNotifyObserver::Activate()

    {

    if ( !IsActive() )

        {

        iStatus = KRequestPending;

        SetActive();

        }

    }

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

// CFileManagerThreadWrapper::CNotifyObserver::Complete()

//

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

void CFileManagerThreadWrapper::CNotifyObserver::Complete(

    RThread& aThread, TInt aResult )

    {

    if ( IsActive() )

        {

        TRequestStatus* status = &iStatus;

        aThread.RequestComplete( status, aResult );

        }

    }

// End of File