/*

* Copyright (c) 2005-2006 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:  State machine for creating directories

*

*/

#include "rsfwmkdirstatemachine.h"

#include "rsfwfileentry.h"

#include "rsfwfiletable.h"

#include "rsfwinterface.h"

#include "rsfwfileengine.h"

#include "mdebug.h"

#include "rsfwdirentattr.h"

#include "rsfwvolumetable.h"

// Make dir

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

// CRsfwMkDirStateMachine::CRsfwMkDirStateMachine

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

//    

CRsfwMkDirStateMachine::CRsfwMkDirStateMachine()

    {

    }

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

// CRsfwMkDirStateMachine::~CRsfwMkDirStateMachine

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

//    

CRsfwMkDirStateMachine::~CRsfwMkDirStateMachine() 

    {

    delete iDirEntAttr;

    }

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

// CRsfwMkDirStateMachine::CompleteRequestL

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

//    

CRsfwRfeStateMachine::TState* CRsfwMkDirStateMachine::CompleteRequestL(TInt aError) 

    {

    if (iKidCreated && aError)

        {

        if ( aError == KErrNotFound )

            {

            User::Leave( KErrNotFound );

            }

        delete iKidFep;

        iKidFep = NULL;

        }

    // it may happen by chance that the new name is equal to iLastFailedLookup value

    FileEngine()->ResetFailedLookup();

    CompleteAndDestroyState()->SetErrorCode(aError);

    return CompleteAndDestroyState();

    }

// Check if exists

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

// CRsfwMkDirStateMachine::TCheckIfExistsState::TCheckIfExistsState

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

//    

CRsfwMkDirStateMachine::

TCheckIfExistsState::TCheckIfExistsState(CRsfwMkDirStateMachine* aParent)

    : iOperation(aParent)

    {

    }

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

// CRsfwMkDirStateMachine::TCheckIfExistsState::EnterL

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

//    

void CRsfwMkDirStateMachine::TCheckIfExistsState::EnterL() 

    {

    TRfeMkdirInArgs* inArgs =

        static_cast<TRfeMkdirInArgs*>(iOperation->iInArgs);

    TPtrC kidName(inArgs->iEntry.iName);

    iOperation->iKidFep = NULL;

    iOperation->iKidCreated = EFalse;

    // the parent to which we are making             

    if (!iOperation->Node())

        {

        User::Leave(KErrNotFound);

        }

    DEBUGSTRING16(("making directory '%S' in fid %d",

                   &kidName,

                   iOperation->Node()->Fid().iNodeId));    

    // Do we know about the kid yet?

    iOperation->iKidFep = iOperation->Node()->FindKidByName(kidName);

    if (!iOperation->iKidFep)

        {

        // This is either a completely new directory,

        // or a directory that we have not yet created a file entry for.

        // (should always happen)

        if (!iOperation->Volumes()->EnsureMetadataCanBeAddedL(iOperation->Node()))

            {

            User::Leave(KErrNoMemory);  

            }        

        iOperation->iKidFep = CRsfwFileEntry::NewL(kidName, iOperation->Node());

        iOperation->iKidCreated = ETrue;

        }

    iOperation->FileEngine()->GetAttributesL(*iOperation->iKidFep,

                                             iOperation->iDirEntAttr,

                                             KNodeTypeDir,

                                             iOperation);

    }

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

// CRsfwMkDirStateMachine::TCheckIfExistsState::CompleteL

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

//    

CRsfwMkDirStateMachine::TState*

CRsfwMkDirStateMachine::TCheckIfExistsState::CompleteL()

    {

    // GetAttributes returned KErrNone

    // directory exist and we return KErrAlreadyExitsts

    return iOperation->CompleteRequestL(KErrAlreadyExists); 

    }

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

// CRsfwMkDirStateMachine::TCheckIfExistsState::ErrorL

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

//    

CRsfwMkDirStateMachine::TState*

CRsfwMkDirStateMachine::TCheckIfExistsState::ErrorL(TInt /*aCode*/)

    {

    // GetAttributes returned error - 

    // directory does not exists, let's create it

    return new CRsfwMkDirStateMachine::TMakeDirectoryState(iOperation);

    }

// Make directory

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

// CRsfwMkDirStateMachine::TMakeDirectoryState::TMakeDirectoryState

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

//    

CRsfwMkDirStateMachine::

TMakeDirectoryState::TMakeDirectoryState(CRsfwMkDirStateMachine* aParent)

    : iOperation(aParent)

    {

    }

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

// CRsfwMkDirStateMachine::TMakeDirectoryState::EnterL

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

//    

void CRsfwMkDirStateMachine::TMakeDirectoryState::EnterL() 

    {

    // Make the directory

    if (!iOperation->FileEngine()->Disconnected())

        {

        HBufC* kidPath =

            iOperation->FileEngine()->FullNameLC(*iOperation->iKidFep);

        iOperation->FileEngine()->RemoteAccessL()->MakeDirectoryL(*kidPath,

                                                                  iOperation);

        CleanupStack::PopAndDestroy(kidPath);

        }

    }

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

// CRsfwMkDirStateMachine::TMakeDirectoryState::CompleteL

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

//    

CRsfwMkDirStateMachine::TState*

CRsfwMkDirStateMachine::TMakeDirectoryState::CompleteL()

    {

    iOperation->iKidFep->SetType(KNodeTypeDir);

    iOperation->FileEngine()->SetupAttributes(*iOperation->iKidFep);    

    // Attach the kid

    if (iOperation->iKidCreated)

        {

        iOperation->FileEngine()->iFileTable->AddL(iOperation->iKidFep);

        iOperation->Node()->AddKid(*iOperation->iKidFep);

        }

    // Create an empty container file locally

    iOperation->FileEngine()->CreateContainerFileL(*iOperation->iKidFep);

    iOperation->iKidFep->SetCached(ETrue);

    iOperation->iKidFep->SetAttribValidationTime();

    // Refresh parent directory next time it is accessed

    iOperation->Node()->SetLocallyDirty();

    return iOperation->CompleteRequestL(KErrNone);

    }

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

// CRsfwMkDirStateMachine::TMakeDirectoryState::ErrorL

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

//    

CRsfwMkDirStateMachine::TState*

CRsfwMkDirStateMachine::TMakeDirectoryState::ErrorL(TInt aCode)

    {

    DEBUGSTRING(("remote mkdir failed!"));

    return iOperation->CompleteRequestL(aCode);

    }