/*

* 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:  Client side implementation of Remote Storage FW API 

 *              : for control functions such as mounting and unmounting.

 *

*/

// INCLUDE FILES

#include "rsfwcommon.h"

#include "rsfwcontrol.h"

// CONSTANTS

#ifdef __WINS__

const TUint KServerMinHeapSize =   0x1000;  //  4K

const TUint KServerMaxHeapSize = 0x100000;  // 64K

#endif

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

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

// RRsfwControl::RRsfwControl

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

// might leave.

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

//

EXPORT_C RRsfwControl::RRsfwControl() : RSessionBase()

    {

    }

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

// RRRsfwControl::Connect

// Connects to the framework by starting the server if neccessary and creating

// a session.

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwControl::Connect()

    {

    const TInt KTryCount = 3;

    TInt err;

    TBool retry;

    TInt i = KTryCount;

    do

        {

        err = StartServer(KRfeServerName);

        if (err == KErrNone)

            {

            err = CreateSession(KRfeServerName,

                                Version(),

                                KDefaultMessageSlots);

            }

        retry = ((err == KErrNotFound) || (err == KErrServerTerminated));

        } while (retry && (++i <= KTryCount));

    return err;

    }

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

// RRsfwControl::Version

// Returns the version of Remote File Engine

// (other items were commented in a header).

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

//

EXPORT_C TVersion RRsfwControl::Version()

    {

    return(TVersion(KRfeMajorVersionNumber,

                    KRfeMinorVersionNumber,

                    KRfeBuildVersionNumber));

    }

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

// RRsfwControl::Mount

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

//

EXPORT_C TInt RRsfwControl::Mount(TInt aDriveLetter)

    {

    TIpcArgs args;

    args.Set(0, aDriveLetter);

    return SendRequest(EMountByDriveLetter, args);

    }

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

// RRsfwControl::Mount

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

//

EXPORT_C TInt RRsfwControl::Mount(const TRsfwMountConfig& aMountConfig)

    {

    TPckg<TRsfwMountConfig> pckgMountConfig(aMountConfig);

    return SendRequest(EMount, TIpcArgs(&pckgMountConfig));

    }

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

// RRsfwControl::Mount

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

//

EXPORT_C TInt RRsfwControl::MountBlind(TInt aDriveLetter)

    {

    iArgs.Set(0, aDriveLetter);

    return Send(EMountByDriveLetter, iArgs);

    }

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

// RRsfwControl::Mount

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

//

EXPORT_C void RRsfwControl::Mount(const TRsfwMountConfig& aMountConfig,

                                  TRequestStatus& aStatus)

    {

    aStatus = KRequestPending;

    iPckgBufMountConfig = aMountConfig;

    SendRequest(EMount, TIpcArgs(&iPckgBufMountConfig), aStatus);

    }

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

// RRsfwControl::DismountByVolumeId

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

//

EXPORT_C TInt RRsfwControl::DismountByVolumeId(TInt aVolumeId)

    {

    return SendRequest(EDismountByVolumeId, TIpcArgs(aVolumeId));

    }

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

// RRsfwControl::DismountByDriveLetter

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

//

EXPORT_C TInt RRsfwControl::DismountByDriveLetter(TChar aDriveLetter)

    {

    aDriveLetter.UpperCase();

    return SendRequest(EDismountByDriveLetter, TIpcArgs(aDriveLetter));

    }

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

// RRsfwControl::GetMountInfo

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

//

EXPORT_C TInt RRsfwControl::GetMountInfo(const TChar& aDriveLetter,

                                         TRsfwMountInfo& aMountInfo)

    {

    TPckg<TRsfwMountInfo> pckgMountInfo(aMountInfo);

    SendRequest(EGetMountInfo, TIpcArgs(aDriveLetter, &pckgMountInfo));

    TInt err;

    if (aMountInfo.iMountConfig.iUri.Length())

        {

        err = KErrNone;

        }

    else

        {

        err = KErrNotFound;

        }

    return err;

    }

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

// RRsfwControl::SetMountConnectionState

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

//

EXPORT_C TInt RRsfwControl::SetMountConnectionState(const TChar& aDriveLetter,

                                                    TUint aState)

    {

    // send a blind request

    return Send(ESetMountConnectionState,

                       TIpcArgs(aDriveLetter,

                                aState));

    }

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

// RRsfwControl::RefreshDirectoryL

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

//

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

    {

    return(SendRequest(EDirRefresh, TIpcArgs(&aPath)));

    }

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

// RRsfwControl::CancelAllRemoteTransfers

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

//

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

    {

    // server must be running in order to successfully cancel anything

    return(SendReceive(ECancelAll, TIpcArgs(&aFile)));

    }

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

// RRsfwControl::StartServer

// Starts the Remote File Engine if it is not running, uses semaphore to 

// synchronize startup.

// (other items were commented in a header).

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

//

TInt RRsfwControl::StartServer(const TDesC& aServerName)

    {

    TInt err;

    TFindServer findRfe(aServerName);

    TFullName name;

    err = findRfe.Next(name);

    if (err == KErrNone)

        {

        // Server already running

        return KErrNone;

        }

    RSemaphore semaphore;       

    err = semaphore.CreateGlobal(KRfeSemaphoreName, 0);

    if (err != KErrNone)

        {

        return err;

        }

    err = CreateServerProcess(aServerName);

    if (err != KErrNone)

        {

        semaphore.Close();  

        return  err;

        }

    semaphore.Wait();

    semaphore.Close();       

    return  KErrNone;

    }

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

// RRRsfwControl::CreateServerProcess

// Starts the Remote File Engine using name to find the binary

// (other items were commented in a header).

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

//

TInt RRsfwControl::CreateServerProcess(const TDesC& aServerName)

    {

    TInt err;

    // just load anything that matches with the name

    const TUidType serverUid(KNullUid, KNullUid, KNullUid);

    RProcess server;

    _LIT(KStartCommand, "");

    err = server.Create(aServerName, KStartCommand, serverUid);

    if (err != KErrNone)

        {

        return err;

        }

    server.Resume();

    server.Close();

    return  KErrNone;

    }

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

// RRsfwControl::SendRequest

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

//    

TInt RRsfwControl::SendRequest(TInt aOpCode, TIpcArgs aArgs)

    {

    TInt err = SendReceive(aOpCode, aArgs);

    if (err == KErrServerTerminated)

        {

        // Close handle before opening new, otherwise client leaks old handle and panics CONE 36

        Close(); 

        // try to restart the server

        err = Connect();

        if (err == KErrNone) 

            {

            err = SendReceive(aOpCode, aArgs);

            }   

        }

    return err;

    }

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

// RRsfwControl::SendRequest

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

//   

void RRsfwControl::SendRequest(TInt aOpCode,

                               TIpcArgs aArgs,

                               TRequestStatus& aStatus)

    {

    SendReceive(aOpCode, aArgs, aStatus);

    }

//  End of File