/*

* 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:  RSFW Mount Manager API

*

*/

// INCLUDE FILES

#include <rsfwmountman.h>

#include "rsfwmountmanimpl.h"

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

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

// TRsfwMountConfig::ExternalizeL

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

//

EXPORT_C void TRsfwMountConfig::ExternalizeL(RWriteStream& aStream) const

    {

    aStream.WriteUint32L(iDriveLetter);

    aStream << iName;

    aStream << iUri;

    aStream << iUserName;

    // Don't externalize a password that is not part of the mount configuration

    // (this is for security)

    if (iFlags & KMountFlagAskPassword)

        {

        TPtrC emptyPassword;

        aStream << emptyPassword;

        }

    else

        {

        aStream << iPassword;

        }

    aStream << iAuxData;

    aStream.WriteUint32L(iFlags);

    aStream.WriteInt32L(iInactivityTimeout);

    }

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

// TRsfwMountConfig::InternalizeL

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

//

EXPORT_C void TRsfwMountConfig::InternalizeL(RReadStream& aStream)

    {

    iDriveLetter = aStream.ReadUint32L();

    aStream >> iName;

    aStream >> iUri;

    aStream >> iUserName;

    aStream >> iPassword;

    aStream >> iAuxData;

    iFlags = aStream.ReadUint32L();

    iInactivityTimeout = aStream.ReadInt32L();

    }

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

// TRsfwMountInfo::ExternalizeL

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

//

void TRsfwMountInfo::ExternalizeL(RWriteStream& aStream) const

    {

    iMountConfig.ExternalizeL(aStream);

    }

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

// TRsfwMountInfo::InternalizeL

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

//

void TRsfwMountInfo::InternalizeL(RReadStream& aStream)

    {

    Mem::FillZ(this, sizeof(*this));

    iMountConfig.InternalizeL(aStream);

    }

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

// CRsfwMountMan::CRsfwMountMan

// Constructor

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

//

CRsfwMountMan::CRsfwMountMan()

    {

    }

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

// CRsfwMountMan::ConstructL

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

//

void CRsfwMountMan::ConstructL(TUint aDefaultFlags,

                           MRsfwMountManObserver* aMountManObserver)

    {

    iMountManImpl = CRsfwMountManImpl::NewL(aDefaultFlags, aMountManObserver);

    }

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

// CRsfwMountMan::NewL

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

//

EXPORT_C CRsfwMountMan* CRsfwMountMan::NewL(TUint aDefaultFlags,

                                    MRsfwMountManObserver* aMountManObserver)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aDefaultFlags, aMountManObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// CRsfwMountMan::~CRsfwMountMan

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

//

EXPORT_C CRsfwMountMan::~CRsfwMountMan()

    {

    delete iMountManImpl;

    }

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

// CRsfwMountMan::GetMountNamesL

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

//

EXPORT_C void CRsfwMountMan::GetMountNamesL(CDesC16Array* aNames) const

    {

    iMountManImpl->GetMountNamesL(aNames);

    }

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

// CRsfwMountMan::MountEntry

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

//

EXPORT_C const CRsfwMountEntry* CRsfwMountMan::MountEntryL(const TDesC& aName) const

    {

    return iMountManImpl->MountEntryL(aName);

    }

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

// CRsfwMountMan::MountEntry

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

//

EXPORT_C const CRsfwMountEntry* CRsfwMountMan::MountEntryL(TChar aDriveLetter) const

    {

    return iMountManImpl->MountEntryL(aDriveLetter);

    }

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

// CRsfwMountMan::AddMountEntryL

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

//

EXPORT_C void CRsfwMountMan::AddMountEntryL(CRsfwMountEntry* aMountEntry)

    {

    iMountManImpl->AddMountEntryL(aMountEntry);

    }

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

// CRsfwMountMan::DeleteMountEntry

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

//

EXPORT_C void CRsfwMountMan::DeleteMountEntryL(const TDesC& aName)

    {

    iMountManImpl->DeleteMountEntryL(aName);

    }

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

// CRsfwMountMan::DeleteMountEntry

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

//

EXPORT_C void CRsfwMountMan::DeleteMountEntryL(TChar aDriveLetter)

    {

    iMountManImpl->DeleteMountEntryL(aDriveLetter);

    }

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

// CRsfwMountMan::GetAllDrivesL

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

//

EXPORT_C TInt CRsfwMountMan::GetAllDrivesL(TDriveList& aDriveList) const

    {

    return iMountManImpl->GetAllDrivesL(aDriveList);

    }

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

// CRsfwMountMan::GetRemoteMountList

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

//

EXPORT_C TInt CRsfwMountMan::GetRemoteMountListL(TDriveList& aDriveList) const

    {

    return iMountManImpl->GetRemoteMountListL(aDriveList);

    }

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

// CRsfwMountMan::GetMountInfo

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

//

EXPORT_C TInt CRsfwMountMan::GetMountInfo(TChar aDriveLetter,

                                      TRsfwMountInfo& aMountInfo) const

    {

    return iMountManImpl->GetMountInfo(aDriveLetter, aMountInfo);

    }

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

// CRsfwMountMan::SetMountConnectionState

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

//

EXPORT_C TInt CRsfwMountMan::SetMountConnectionState(TChar aDriveLetter,

                                                 TUint aConnectionState)

    {

    if (aConnectionState == KMountStronglyConnected) 

        {

        TRsfwMountConfig mountConfig;

	    mountConfig.iDriveLetter = aDriveLetter;

	    mountConfig.iFlags = KMountFlagMountAtRfeOnly;

	    TRAPD(err, iMountManImpl->MountL(aDriveLetter));

	    return err;

        }

   else 

        {

        return iMountManImpl->SetMountConnectionState(aDriveLetter,

                                                  aConnectionState);     

        }

    }

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

// CRsfwMountMan::SetMountConnectionStateBlind

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

//

EXPORT_C TInt CRsfwMountMan::SetMountConnectionStateBlind(TChar aDriveLetter,

                                                 TUint aConnectionState)

    {

    if (aConnectionState == KMountStronglyConnected) 

        {

        TRsfwMountConfig mountConfig;

	    mountConfig.iDriveLetter = aDriveLetter;

	    mountConfig.iFlags = KMountFlagMountAtRfeOnly;

	    TRAPD(err, iMountManImpl->MountBlindL(aDriveLetter));

	    return err;

        }

   else 

        {

        return iMountManImpl->SetMountConnectionState(aDriveLetter,

                                                  aConnectionState);     

        }

    }

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

// CRsfwMountMan::EditMountEntryL

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

//

EXPORT_C void CRsfwMountMan::EditMountEntryL(CRsfwMountEntry* aMountEntry)

    {

    iMountManImpl->EditMountEntryL(aMountEntry);

    }    

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

// CRsfwMountMan::RefreshDirectoryL

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

//

EXPORT_C TInt CRsfwMountMan::RefreshDirectory(const TDesC& aPath)

    {

    return iMountManImpl->RefreshDirectory(aPath);

    }

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

// CRsfwMountMan::IsAppOnBlackList

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

//

EXPORT_C TBool CRsfwMountMan::IsAppOnBlackList(TUid aUid) const

    {

    return iMountManImpl->IsAppOnBlackList(aUid);

    }    

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

// CRsfwMountMan::CancelAllRemoteTransfers

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

//

EXPORT_C TInt CRsfwMountMan::CancelRemoteTransfer(const TDesC& aFile)

    {

    return iMountManImpl->CancelRemoteTransfer(aFile);

    }    

//  End of File