/*

* Copyright (c) 2002-2004 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:  Synchronous layer on top of the Access Protocol plug-in API

 *

*/

// INCLUDE FILES

#include "rsfwremoteaccesssync.h"

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

CRsfwRemoteAccessSync* CRsfwRemoteAccessSync::NewL(const TDesC8& aService,

                                           CRsfwRemoteAccess* aRemoteAccess)

    {

    CRsfwRemoteAccessSync* self = new (ELeave) CRsfwRemoteAccessSync;

    CleanupStack::PushL(self);

    self->ConstructL(aService, aRemoteAccess);

    CleanupStack::Pop(self);

    return self;

    }

void CRsfwRemoteAccessSync::ConstructL(const TDesC8& aService,

                                   CRsfwRemoteAccess* aRemoteAccess)

    {

    if (aRemoteAccess)

        {

        iRemoteAccess = aRemoteAccess;

        }

    else

        {

        iRemoteAccess = CRsfwRemoteAccess::NewL(aService);

        iOwnRemoteAccess = ETrue;

        }

    iSchedulerWait = new CActiveSchedulerWait();   

    }

CRsfwRemoteAccessSync::~CRsfwRemoteAccessSync()

    {

    if (iOwnRemoteAccess)

        {

        delete iRemoteAccess;

        }

    delete iSchedulerWait;    

    }

TInt CRsfwRemoteAccessSync::Setup(

    MRsfwRemoteAccessObserver* aRsfwRemoteAccessObserver)

    {

    TRAPD(err, iRemoteAccess->SetupL(aRsfwRemoteAccessObserver));

    return err;

    }

TInt CRsfwRemoteAccessSync::Open(const TDesC& aUserName,

                             const TDesC& aPassword,

                             const TDesC& aServerName,

                             TInt aPortNumber,

                             const TDesC& aRootDirectory,

                             const TDesC& aAuxData)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TBuf<KMaxPath> url;

    url.Append(_L("http://"));

    url.Append(aServerName);

    url.Append(_L(":"));

    url.AppendNum(aPortNumber);

    url.Append(_L("/"));

    url.Append(aRootDirectory);

    TUriParser uriParser;

    uriParser.Parse(url);

    TRAP(iStatus, iRemoteAccess->OpenL(uriParser,

                                       aServerName,

                                       aUserName,

                                       aPassword,

                                       aAuxData,

                                       this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::GetDirectory(const TDesC& aPathName,

                                     RPointerArray<CRsfwDirEnt>& aDirEnts)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->GetDirectoryL(aPathName,

                                               aDirEnts,

                                               this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::GetFile(const TDesC& aRemotePathName,

                                const TDesC& aLocalPathName,

                                TInt aOffset,

                                TInt* aLength,

                                TUint aFlags)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->GetFileL(aRemotePathName,

                                          aLocalPathName,

                                          aOffset,

                                          aLength,

                                          aFlags,

                                          this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::MakeDirectory(const TDesC& aPathName)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->MakeDirectoryL(aPathName, this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::CreateFile(const TDesC& aPathName)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->CreateFileL(aPathName, 0, this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::PutFile(const TDesC& aLocalPathName,

                                const TDesC& aRemotePathName)

    {

    _LIT8(KTextPlain, "text/plain");

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->PutFileL(aLocalPathName,

                                          aRemotePathName,

                                          KTextPlain,

                                          this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::DeleteDirectory(const TDesC& aPathName)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->DeleteDirectoryL(aPathName, this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::DeleteFile(const TDesC& aPathName)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->DeleteFileL(aPathName, this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::Rename(const TDesC& aSrcPathName,

                               const TDesC& aDstPathName,

                               TBool aOverwrite)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->RenameL(aSrcPathName,

                                         aDstPathName,

                                         aOverwrite,

                                         this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::GetDirectoryAttributes(const TDesC& aPathName,

                                               CRsfwDirEntAttr*& aAttr)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus,

         iRemoteAccess->GetDirectoryAttributesL(aPathName, aAttr, this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::GetFileAttributes(const TDesC& aPathName,

                                          CRsfwDirEntAttr*& aAttr)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->GetFileAttributesL(aPathName,

                                                    aAttr,

                                                    this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::SetAttributes(const TDesC& aPathName,

                                      CRsfwDirEntAttr& aAttr)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->SetAttributesL(aPathName, aAttr, this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::ObtainLock(const TDesC& aPathName,

                                   TUint aLockFlags,

                                   TUint& aTimeout,

                                   TDesC8*& aLockToken)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus,

         iRemoteAccess->ObtainLockL(aPathName,

                                    aLockFlags,

                                    aTimeout,

                                    aLockToken,

                                    this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::ReleaseLock(const TDesC& aPathName)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->ReleaseLockL(aPathName, this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::RefreshLock(const TDesC& aPathName,

                                    TUint& aTimeout)

    {

    if (iPending)

        {

        return KErrServerBusy;

        }

    iPending = ETrue;

    TRAP(iStatus, iRemoteAccess->RefreshLockL(aPathName, aTimeout, this));

    return Epilog();

    }

TInt CRsfwRemoteAccessSync::SetLockToken(const TDesC& aPathName,

                                     const TDesC8& aLockToken)

    {

    return iRemoteAccess->SetLockToken(aPathName, aLockToken);

    }

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

// from MRemoteAccessResponseHandler

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

void CRsfwRemoteAccessSync::HandleRemoteAccessResponse(TUint /* aId */,

                                                   TInt aStatus)

    {

    iStatus = aStatus;

    if (iSchedulerWait->IsStarted())

        {

        iSchedulerWait->AsyncStop();

        }

    iPending = EFalse;

    }

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

TInt CRsfwRemoteAccessSync::Epilog()

    {

    if (iPending && (iStatus == KErrNone))

        {

        iSchedulerWait->Start();

        }

    return iStatus;

    }

// End of File