#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cusbhostmssessionTraces.h"

#endif

    param   aServer     Service the session will be a member of

    param   aMessage    The message from the client.

    return  A new CUsbHostMsSession object

    {

    CUsbHostMsSession* r = new (ELeave) CUsbHostMsSession(aServer);

    CleanupStack::PushL(r);

    r->ConstructL();

    CleanupStack::Pop();

    return r;

    }

    param   aServer Service the session will be a member of

    : iUsbHostMsServer(aServer)

    {

    }

    {

    iUsbHostMsServer.IncrementSessionCount();

    OstTrace1(TRACE_SHOSTMASSSTORAGE_HOST, CUSBHOSTMSSESSION_10,

              "iSessionCount: %d", iUsbHostMsServer.SessionCount());

    }

    {

    iUsbHostMsServer.DecrementSessionCount();

    iThread.Close();

    OstTrace1(TRACE_SHOSTMASSSTORAGE_HOST, CUSBHOSTMSSESSION_11,

              "Closed a session -> iSessionCount: %d",

              iUsbHostMsServer.SessionCount());

    }

    param   aMessage    Message received from the client

    {

    DispatchMessageL(aMessage);

    }

    param   aMessage    The received message

    {

    TInt r = KErrNone;

    switch (aMessage.Function())

        {

    case EUsbHostMsRegisterInterface:

        TRAP(r, CreateDeviceThreadL(aMessage));

        if(r != KErrNone)

            {

            aMessage.Complete(r);

            return;

            }

        break;

        break;

    /* If it is a cleanup then we need to delete the iDeviceThread */

    case EUsbHostMsFinalCleanup:

        delete iDeviceThread;

        iDeviceThread = NULL;

        iThread.Kill(KErrNone);

        aMessage.Complete(KErrNone);

        return;

    default:

        break;

        }

    if (iDeviceThread == NULL)

        {

        aMessage.Complete(KErrBadHandle);

        return;

        }

    if (iCleanupInProgress && aMessage.Function() != EUsbHostMsUnRegisterInterface)

    r = iDeviceThread->QueueMsg(aMessage);

    if (r != KErrNone)

        {

        aMessage.Complete(r);

        return;

        }

    if (iClientStatus && *iClientStatus == KRequestPending)

        {

        OstTrace0(TRACE_SHOSTMASSSTORAGE_HOST, CUSBHOSTMSSESSION_20,

                  "Signaling device thread to handle message");

        iThread.RequestComplete(iClientStatus, KErrNone);

        }

    }

    {

    THostMassStorageConfig msDeviceConfig;

    TPtr8 ptr((TUint8*)&msDeviceConfig,sizeof(THostMassStorageConfig));

    aMessage.ReadL(0, ptr);

    OstTrace1(TRACE_SHOSTMASSSTORAGE_HOST, CUSBHOSTMSSESSION_21,

              "EUsbHostMsRegisterInterface Token=%d ", msDeviceConfig.iInterfaceToken);

    nameBuf.Format(_L("Host Ms Thread%8x"), msDeviceConfig.iInterfaceToken);

    iDeviceThread = CUsbHostMsDeviceThread::NewL(*this, msDeviceConfig.iInterfaceToken);

    RHeap* h = (RHeap*)&User::Allocator();

    TInt maxsize = h->MaxLength();  // loader heap max size = file server heap max size

    const TUint KHeapMinSize = 2048;

    TInt r = iThread.Create(nameBuf, CUsbHostMsDeviceThread::Entry, KDefaultStackSize, KHeapMinSize, maxsize, iDeviceThread);

    if(r != KErrNone)

        {

        delete iDeviceThread;

        User::Leave(r);

        }

    iThread.SetPriority(EPriorityAbsoluteForeground);

    TRequestStatus status;

    iThread.Rendezvous(status);

    iThread.Resume();

    User::WaitForRequest(status);

    if(status != KErrNone)

        {

        delete iDeviceThread;

        iThread.Kill(KErrNone);

        User::Leave(status.Int());

        }

    }