/*

* 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:

*

*/

/**

 @file

 @internalComponent

*/

#include "msmmserver.h"

#include "msmm_internal_def.h"

#include "msmmsession.h"

#include "msmmengine.h"

#include "eventqueue.h"

#include "msmmterminator.h"

#endif

//  Static public functions

TInt CMsmmServer::ThreadFunction()

    {

    TInt ret = KErrNone;

    __UHEAP_MARK;

    // Create the cleanup stack

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if (cleanupStack)

        {

        TRAP(ret, ThreadFunctionL());

        delete cleanupStack;

        }

    else

        {

        ret = KErrNoMemory;

        }

    __UHEAP_MARKEND;

    return ret;

    }

void CMsmmServer::ThreadFunctionL()

    {

    TSecureId creatorSID = User::CreatorSecureId();

    if (KFDFWSecureId != creatorSID)

        {

        // Only FDF process can be the creator of the MSMM server

        User::Leave(KErrPermissionDenied);

        }

    // Create and install the active scheduler

    CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

    CleanupStack::PushL(scheduler);

    CActiveScheduler::Install(scheduler);

    // Create the server and leave it on cleanup stack

    CMsmmServer::NewLC();

    // Signal the client that the server is up and running

    RProcess::Rendezvous(KErrNone);

    RThread().SetPriority(EPriorityAbsoluteHigh);

    // Start the active scheduler, the server will now service 

    // request messages from clients.

    CActiveScheduler::Start();

    // Free the server and active scheduler.

    CleanupStack::PopAndDestroy(2, scheduler);

    }

// Public functions

// Construction and destruction

CMsmmServer* CMsmmServer::NewLC()

    {

    CMsmmServer* self = new (ELeave) CMsmmServer(EPriorityHigh);

    CleanupStack::PushL(self);

    // Create a server with unique server name

    self->StartL(KMsmmServerName);

    self->ConstructL();

    return self;

    }

CMsmmServer::~CMsmmServer()

    {

    delete iPolicyPlugin;

    delete iEventQueue;

    delete iEngine;

    delete iTerminator;

    REComSession::FinalClose();

#ifndef __OVER_DUMMYCOMPONENT__

    iFs.RemoveProxyDrive(KPROXYDRIVENAME);

    iFs.Close();

#endif

    }

    // CMsmmServer APIs

CSession2* CMsmmServer::NewSessionL(const TVersion& aVersion, 

        const RMessage2& aMessage) const

    {

    if (KMaxClientCount <= SessionNumber())

        {

        // There is a connection to MSMM server already.

        // at any time.

        User::Leave(KErrInUse);

        }

    // Check the client-side API version number against the server version 

    // number.

    TVersion serverVersion(KMsmmServMajorVersionNumber,

        KMsmmServMinorVersionNumber, KMsmmServBuildVersionNumber);

    if (!User::QueryVersionSupported(serverVersion, aVersion))

        {

        // Server version incompatible with client-side API

        PanicClient(aMessage, ENoSupportedVersion);

        User::Leave(KErrNotSupported);

        }

    // Version number is OK - create the session

    return CMsmmSession::NewL(*(const_cast<CMsmmServer*>(this)), *iEventQueue);

    }

TInt CMsmmServer::SessionNumber() const

    {

    return iNumSessions;

    }

void CMsmmServer::AddSession()

    {

    ++iNumSessions;

    iTerminator->Cancel();

    }

void CMsmmServer::RemoveSession()

    {

    --iNumSessions;

    if (iNumSessions == 0)

        {

        // Discard all pending adding interface events from queue

        // and cancel event handler if a adding events is being 

        // handled in it.

        iEventQueue->Finalize();

        iTerminator->Cancel();

        iTerminator->Start();

        }

    }

//  Private functions 

// CMsmmServer Construction

CMsmmServer::CMsmmServer(TInt aPriority)

    :CPolicyServer(aPriority, KMsmmServerSecurityPolicy, EUnsharableSessions)

    {

    }

void CMsmmServer::ConstructL()

    {

    iEngine = CMsmmEngine::NewL();

    iEventQueue = CDeviceEventQueue::NewL(*this);

    iTerminator = CMsmmTerminator::NewL(*iEventQueue);

    iPolicyPlugin = CMsmmPolicyPluginBase::NewL();

    if (!iPolicyPlugin)

        {

        // Not any policy plugin implementation available

        PanicServer(ENoPolicyPlugin);

        }

    // Initalize RFs connection and add the ELOCAL file system to file server

    User::LeaveIfError(iFs.Connect());

#ifndef __OVER_DUMMYCOMPONENT__

    TInt ret(KErrNone);

    ret = iFs.AddProxyDrive(KFSEXTNAME);

    if ((KErrNone != ret) && (KErrAlreadyExists !=  ret))

        {

        User::Leave(ret);

        }

#endif

    // Start automatic shutdown timer

    iTerminator->Start();

    }

// End of file