/*

* 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:  Asynchronous File Saving Queue

*

*/

// INCLUDE FILES

#include <asynchfsq.h>

#include <bautils.h> // for deleting files

#include "asynchatom.h"

// CONSTANTS

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

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

// CAsynchFSQ::CAsynchFSQ

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

// might leave.

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

//

CAsynchFSQ::CAsynchFSQ()

    {

    LOGTEXT( _L( "CAsynchFSQ::CAsynchFSQ() entering" ) );

    }

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

// CAsynchFSQ::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAsynchFSQ::ConstructL()

    {

    LOGTEXT( _L( "CAsynchFSQ::ConstructL() entering" ) );

    iPriority = EPriorityNormal;

    iManualStart = EFalse;

    LOGTEXT( _L( "CAsynchFSQ::ConstructL() exiting" ) );

    }

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

// CAsynchFSQ::NewL

// Two-phased constructor.

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

//

EXPORT_C CAsynchFSQ* CAsynchFSQ::NewL()

    {

    LOGTEXT( _L( "CAsynchFSQ::NewL() entering" ) );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CAsynchFSQ::~CAsynchFSQ   

// Destructor

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

//

CAsynchFSQ::~CAsynchFSQ()

    {

    LOGTEXT( _L( "CAsynchFSQ::~CAsynchFSQ() entering" ) );

    // clean up queues

    iQueue.ResetAndDestroy();

    LOGTEXT( _L( "CAsynchFSQ::~CAsynchFSQ() exiting" ) );

    }

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

// CAsynchFSQ::SaveAndDestroy

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

//

EXPORT_C TInt CAsynchFSQ::SaveAndDestroy( TDesC8& aData, const TDesC& aPath, TBool aOverwrite )

    {

    LOGTEXT( _L( "CAsynchFSQ::SaveAndDestroy() entering" ) );

    TInt err = KErrNone;

    // return if NULL descriptor.

    if( !&aData )

        {

        return KErrArgument;

        }

    iOverwrite = aOverwrite;

    LOGTEXT2( _L( "CAsynchFSQ::SaveAndDestroy() iQueue.Count()=%d" ), iQueue.Count() );

    LOGTEXT2( _L( "CAsynchFSQ::SaveAndDestroy() ActionsLeft()=%d" ), ActionsLeft() );

    // add data to our queue

    err = Enqueue( EFileSave, aData, aPath, KNullDesC, ENullSchemaType, KNullDesC, KNullDesC );

    LOGTEXT2( _L( "CAsynchFSQ::SaveAndDestroy() iManualStart=%d" ), iManualStart );

    if ( !err && !iManualStart )

        {

        err = Go();	

        }

    LOGTEXT2( _L( "CAsynchFSQ::SaveAndDestroy() returning err=%d" ), err );

    return err;

    }

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

// CAsynchFSQ::Go

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

//

EXPORT_C TInt CAsynchFSQ::Go()

    {

    LOGTEXT( _L( "CAsynchFSQ::Go() entering" ) );

    TInt err = KErrNone;

    // make sure the queue has at least one object

    if( iQueue.Count() == 0 )

        {

        err = KErrNotReady;	

        }

    // activate AO's

    for( TInt i = 0; i < iQueue.Count(); i++ )

        {

        if(( !err )&&( iQueue[i]->GetState() == EPending ))

            {

            err = iQueue[i]->Go();

            }

        }

    LOGTEXT2( _L( "CAsynchFSQ::Go() returning err=%d" ), err );

    return err;

    }

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

// CAsynchFSQ::SetManualStart

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

//

EXPORT_C void CAsynchFSQ::SetManualStart( TBool aManualStart )

    {

    LOGTEXT( _L( "CAsynchFSQ::ManualStart() entering" ) );

    iManualStart = aManualStart;

    LOGTEXT( _L( "CAsynchFSQ::ManualStart() returning" ) );

    }

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

// CAsynchFSQ::Delete

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

//

EXPORT_C TInt CAsynchFSQ::Delete( const TDesC& aPath )

    {

    LOGTEXT( _L( "CAsynchFSQ::Delete() entering" ) );

	TInt err = KErrNotFound;

    // search for path name and delete if found

    for( TInt i = 0; i < iQueue.Count(); i++ )

        {

        if ( iQueue[i]->DoesLocalSave() )

            {

            if ( (iQueue[i]->GetPath()).Compare( aPath ) == 0 )

                {

                LOGTEXT( _L( "CAsynchFSQ::Delete() file found, deleting" ) );

                err = iQueue[i]->DeleteLocal();

                }

            }

        }

    // if still not found,

    // attempt to delete from file system

    if ( err == KErrNotFound )

        {

        LOGTEXT( _L( "CAsynchFSQ::Delete() not in queues, trying file system" ) );

        RFs fs;

        TInt connectError = fs.Connect();

        BaflUtils ba;

        if( !connectError && ba.FileExists( fs, aPath ) )

            {

            LOGTEXT( _L( "CAsynchFSQ::Delete() exists, deleting from file system" ) );

            err = KErrNone;

            ba.DeleteFile( fs, aPath );

            }

        fs.Close();

        }

    LOGTEXT2( _L( "CAsynchFSQ::Delete() returning err=%d" ), err );

    return err;

    }

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

// CAsynchFSQ::Rename

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

//

EXPORT_C TInt CAsynchFSQ::Rename( const TDesC& aOld, const TDesC& aNew )

    {

    LOGTEXT( _L( "CAsynchFSQ::Rename() entering" ) );

	TInt err = KErrNotFound;

    // search for path name and delete if found

    for( TInt i = 0; i < iQueue.Count(); i++ )

        {

        if ( iQueue[i]->DoesLocalSave() )

            {

            if ( (iQueue[i]->GetPath()).Compare( aOld ) == 0 )

                {

                LOGTEXT( _L( "CAsynchFSQ::Delete() file found, renaming" ) );

                err = iQueue[i]->RenameLocal( aNew );

                }

            }

        }       

    // if still not found,

    // attempt to rename from file system

    if ( err == KErrNotFound )

        {

        LOGTEXT( _L( "CAsynchFSQ::Rename() not in queues, trying file system" ) );

        RFs fs;

        TInt connectError = fs.Connect();

        BaflUtils ba;

        if( !connectError && ba.FileExists( fs, aOld ) )

            {

            LOGTEXT( _L( "CAsynchFSQ::Rename() exists, renaming in file system" ) );

            err = KErrNone;

            ba.RenameFile( fs, aOld, aNew );

            }

        fs.Close();

        }

    LOGTEXT2( _L( "CAsynchFSQ::Rename() returning err=%d" ), err );

    return err;

    }

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

// CAsynchFSQ::SetThreadPriority

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

//

EXPORT_C void CAsynchFSQ::SetPriority( TInt aPriority ) 

    {

    LOGTEXT2( _L( "CAsynchFSQ::SetThreadPriority() entering aPriority=%d" ), aPriority );

    iPriority = aPriority;

    LOGTEXT( _L( "CAsynchFSQ::SetThreadPriority() exiting" ) );

    }

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

// CAsynchFSQ::SetCallback

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

//

EXPORT_C void CAsynchFSQ::SetCallback( MAsynchFSQObserver* aCallback )

    {

    LOGTEXT( _L( "CAsynchFSQ::SetCallback() entering" ) );

    iCallback = aCallback;

    LOGTEXT( _L( "CAsynchFSQ::SetCallback() exiting" ) );

    }

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

// CAsynchFSQ::ActionsLeft

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

//

EXPORT_C TInt CAsynchFSQ::ActionsLeft()

    {

    TInt actionsLeft = 0;

    for( TInt i = 0; i < iQueue.Count(); i++ )

        {

        actionsLeft += iQueue[i]->ActionsLeft();

        }

    LOGTEXT2( _L( "CAsynchFSQ::ActionsLeft() actionsLeft=%d" ), actionsLeft );

    return actionsLeft;

    }

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

// CAsynchFSQ::Cancel

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

//

EXPORT_C void CAsynchFSQ::Cancel()

    {

    LOGTEXT( _L( "CAsynchFSQ::Cancel() entering" ) );

    while( iQueue.Count() )

        {

        delete iQueue[0];

        iQueue[0] = NULL;

        iQueue.Remove( 0 ); // Data MUST be deleted first

        }

    LOGTEXT( _L( "CAsynchFSQ::Cancel() exiting" ) );

    }

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

// CAsynchFSQ::Notify

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

//

void CAsynchFSQ::Notify( TInt aError )

    {

    LOGTEXT( _L( "CAsynchFSQ::Notify() entering" ) );

    iCallback->MAsynchFSQEvent( aError );

    // Scan and delete completed atoms

    for( TInt i = 0; i < iQueue.Count(); i++ )

        {

        if( iQueue[i]->ActionsLeft() == 0 )

            {

            delete iQueue[i];

            iQueue[i] = NULL;

            iQueue.Remove( i ); // Data MUST be deleted first

            i--;

            }

        }

    LOGTEXT( _L( "CAsynchFSQ::Notify() exiting" ) );

    }

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

// CAsynchFSQ::Enqueue

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

//

TInt CAsynchFSQ::Enqueue( TFSQActionType aActionType, TDesC8& aData, 

                          const TDesC& aPath, const TDesC& aURL, 

                          TFSQSchemaType aSchema, const TDesC& aUserName, 

                          const TDesC& aPassword )

    {

    LOGTEXT( _L( "CAsynchFSQ::Enqueue() entering" ) );

    TInt err = KErrNone;

    TInt queueError = KErrNone; 

    TRAP( err,

        // create atom

        CAsynchFSQAtom* atom = 

            CAsynchFSQAtom::NewL( this, 

                                  iPriority,

                                  aActionType,

                                  aData,

                                  aPath,

                                  aURL,

                                  aSchema,

                                  aUserName,

                                  aPassword );

        //append to queue

        iQueue.Append( atom );

        );

    if ( !err && queueError )

        {

        err = queueError;

        }

    LOGTEXT2( _L( "CAsynchFSQ::Enqueue() returning err=%d" ), err );

    return err;

    }

//  End of File