/*

* Copyright (c) 2004-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:  Lock manager for locked remote files

*

*/

#include "rsfwfileentry.h"

#include "rsfwrfestatemachine.h"

#include "rsfwlockmanager.h"

#include "rsfwfileentry.h"

#include "rsfwconfig.h"

#include "mdebug.h"

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

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

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

// CRsfwLockManager::NewL

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

//

CRsfwLockManager* CRsfwLockManager::NewL(CRsfwRemoteAccess* aRemoteAccess)

    {

    CRsfwLockManager* self = CRsfwLockManager::NewLC(aRemoteAccess);

    CleanupStack::Pop(self);

    return self;

    }

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

// CRsfwLockManager::NewLC

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

//

CRsfwLockManager* CRsfwLockManager::NewLC(CRsfwRemoteAccess* aRemoteAccess)

    {

    DEBUGSTRING(("CRsfwLockManager::NewLC"));

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

    CleanupStack::PushL(self);

    self->ConstructL(aRemoteAccess);

    return self;

    }

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

// CRsfwLockManager::ConstructL

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

//

void CRsfwLockManager::ConstructL(CRsfwRemoteAccess* aRemoteAccess)

    {

    iRemoteAccess = aRemoteAccess;

    }

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

// CRsfwLockManager::~CRsfwLockManager

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

//

CRsfwLockManager::~CRsfwLockManager()

    {

    iLockRefreshContexts.Close();

    // set unlock flag for all the entries locked

    while (iLockedEntries.Count() > 0)

        {

        CRsfwFileEntry* entry = iLockedEntries[0];

        iLockedEntries.Remove(0);

        // note that RemoveLocked will call CRsfwLockManager::RemoveLockedEntry

        entry->RemoveLocked();

        }

    iLockedEntries.Close();    

    }

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

// CRsfwLockManager::HandleRemoteAccessResponse

// For handling the response from RefreshLockL().

// If the lock refresh is successful we restart the timer

// as the server may have changed the timeout.

// If the refresh request returns an error we remove the lock

// We assume that server does not hold the lock anymore,

// so we cannot re-acquire it simply by trying to refresh it again.

// Instead, we should do a fresh lock operation

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

//

void CRsfwLockManager::HandleRemoteAccessResponse(TUint aId,

                                              TInt aStatus)

    {

    DEBUGSTRING(("CRsfwLockManager::HandleRemoteAccessResponse id: %d, status: %d", aId, aStatus));

    TPendingLockRefreshContext lockRefresh;

    lockRefresh.iId = aId;

    TInt index = iLockRefreshContexts.Find(lockRefresh);

    if (index != KErrNotFound) 

        {

        lockRefresh = iLockRefreshContexts[index];

        if (aStatus == KErrNone) 

            {

            // Note that this can leave only when creating the timer

            // so it shouldn't really leave anymore at this point.

            // Also resetting the timer and calling Start() do not even

            // return an error, so there is no need to examine err or ret value

            TRAP_IGNORE(lockRefresh.iFileEntry->SetLockedL(this, NULL));

            }

        else 

            {

            lockRefresh.iFileEntry->RemoveLocked();

            }

        iLockRefreshContexts.Remove(index);

        }

    }

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

// CRsfwLockManager::ObtainLockL

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

//

void CRsfwLockManager::ObtainLockL(CRsfwFileEntry *aFileEntry,

                               TUint aLockFlags,

                               TDesC8*& aLockToken,

                               CRsfwRfeStateMachine* aOperation)

    {

    DEBUGSTRING(("CRsfwLockManager::ObtainLockL"));

    if (aFileEntry->iLockTimeout == 0)

        {

        // No locking wanted,

        // we use notsupported as a return code in this case too....

        DEBUGSTRING(("lock timeout in CFileEntry is 0, no locking"));

        aOperation->HandleRemoteAccessResponse(0, KErrNotSupported); 

        }

    else 

        {

        HBufC* fullName = aFileEntry->FullNameLC();

         if (!iRemoteAccess) 

            {

            DEBUGSTRING(("iRemoteAccess NULL"));

            User::Leave(KErrNotReady);

            }

        else 

            {

            DEBUGSTRING(("calling iRemoteAccess::ObtainLockL()"));

            iRemoteAccess->ObtainLockL(*fullName,

                                   aLockFlags,

                                   aFileEntry->iLockTimeout,

                                   aLockToken,

                                   aOperation);

            }

        CleanupStack::PopAndDestroy(fullName); // fullname  

        }

    }

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

// CRsfwLockManager::ReleaseLockL

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

//

void CRsfwLockManager::ReleaseLockL(CRsfwFileEntry* aFileEntry,

                                CRsfwRfeStateMachine* aOperation)

    {

    DEBUGSTRING(("CRsfwLockManager::ReleaseLockL"));

    if (aFileEntry->iLockTimeout == 0)

        {

        // No locking

        User::Leave(KErrNotFound);

        }

    if (!iRemoteAccess) 

        {

        User::Leave(KErrNotReady);

        }

    else 

        {

        HBufC* fullName = aFileEntry->FullNameLC();

#ifdef _DEBUG

        TInt err;

        err = iRemoteAccess->ReleaseLockL(*fullName, aOperation);

        TPtrC p = fullName->Des();

        DEBUGSTRING16(("ReleaseLockL(): returned %d for file '%S'", err, &p));     

#else        

        iRemoteAccess->ReleaseLockL(*fullName, aOperation);

#endif

        CleanupStack::PopAndDestroy(fullName); // fullname

        }

    }

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

// CRsfwLockManager::RefreshLockL

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

//

void CRsfwLockManager::RefreshLockL(CRsfwFileEntry* aFileEntry)

    {

   DEBUGSTRING(("CRsfwLockManager::RefreshLockL"));

    TInt id = 0;

    if (aFileEntry->iLockTimeout > 0) // timeout = 0 indicates no locking

        {

        aFileEntry->iLockTimer->Cancel(); // cancel the old timer

        HBufC* fullName = aFileEntry->FullNameLC();

        TRAPD(err, id = iRemoteAccess->RefreshLockL(*fullName,

                                                    aFileEntry->iLockTimeout,

                                                    this)); 

        if (err == KErrNone) 

            {

            TPendingLockRefreshContext lockRefresh;

            lockRefresh.iId = id;

            lockRefresh.iFileEntry = aFileEntry;

            iLockRefreshContexts.AppendL(lockRefresh);

            } 

        else 

            {

            // This error would come from the lower layers of the communication

            // stack, not from the server.

            // We use the timer mechanism to try again

            // but set the timeout to smaller.

            // Note that we don't touch aFileEntry->iLockTimer, 

            // which will be used to set the timeout requested from the server

            TInt lockTimeout =

                Min((aFileEntry->iLockTimeout / KLockRefreshAdjustment) / 2,

                    KMinLockRefreshAttempt);

            TCallBack callBack(CRsfwFileEntry::LockTimerExpiredL, this);

            aFileEntry->iLockTimer->Start(1000000 * lockTimeout,

                                          1000000 * lockTimeout,

                                          callBack);

            }

        CleanupStack::PopAndDestroy(fullName); // fullname

        }

    }

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

// CRsfwLockManager::LockedCount

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

//  

TInt CRsfwLockManager::LockedCount()

    {

    return iLockedEntries.Count();

    }

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

// CRsfwLockManager::AddLockedEntryL

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

//

void CRsfwLockManager::AddLockedEntryL(CRsfwFileEntry* aEntry)

    {

    // prevent from adding the same item twice

    if (iLockedEntries.Find(aEntry) != KErrNotFound)

        {

        return;

        }

    iLockedEntries.AppendL(aEntry);

    DEBUGSTRING(("Update locked count %d -> %d",

                 iLockedEntries.Count() - 1,

                 iLockedEntries.Count()));

    }

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

// CRsfwLockManager::RemoveLockedEntry

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

//

void CRsfwLockManager::RemoveLockedEntry(CRsfwFileEntry* aEntry)

    {

    TInt index = iLockedEntries.Find(aEntry);

    if (index != KErrNotFound)

        {

        iLockedEntries.Remove(index);        

        DEBUGSTRING(("Update locked count %d -> %d",

                 iLockedEntries.Count() + 1,

                 iLockedEntries.Count()));

        }

    }

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

// CRsfwLockManager::PopulateExternalLockTokenCacheL

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

//

void CRsfwLockManager::PopulateExternalLockTokenCacheL(CRsfwFileEntry* aRoot)

    {

    if (aRoot)

        {

        const TDesC8* lockToken = aRoot->LockToken();

        if (lockToken)

            {

            HBufC* path = aRoot->FullNameLC();

            TPtr pathPtr = path->Des();

            if (aRoot->Type() == KNodeTypeDir)

                {

                // the MaxLength() of path is KMaxPath, so we can append

            if (pathPtr.Length() && (pathPtr[pathPtr.Length() - 1] != '/'))

                {

                pathPtr.Append('/');

                }

                }

            iRemoteAccess->SetLockToken(pathPtr, *lockToken);

            CleanupStack::PopAndDestroy(path);

            }

        RPointerArray<CRsfwFileEntry>* kids = aRoot->Kids();

        TInt i;

        for (i = 0; i < kids->Count(); i++)

            {

            PopulateExternalLockTokenCacheL((*kids)[i]);

            }

        }

    }

//  End of File