cobainserver.cpp

Go to the documentation of this file.

/*
 * cobainserver.cpp,v 1.20 2003/11/20 17:50:18 mattid Exp
 *
 * COBAIN - Communications API for EPOC Environments
 * Copyright (C) 2002-2003 Matti Dahlbom, Matti Kokkola
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Contact: Matti Dahlbom <matti@777-team.org>
 *          Matti Kokkola <matti.kokkola@iki.fi>
 */

#include <e32svr.h>
#include <flogger.h>

#include "cobainserver.h"
#include "serversession.h"
#include "Log.h"

CCobainServer::CCobainServer(TInt aPriority) 
    : CServer(aPriority, ESharableSessions) 
{
#ifndef __WINS__
    Log::Init();
#endif
}

CCobainServer::~CCobainServer()
{
    Log::Print(_L("** server dying"));
}

CCobainServer* CCobainServer::NewL() 
{
    CCobainServer *server = new (ELeave)CCobainServer(CServer::EPriorityStandard);
    CleanupStack::PushL(server);
    server->ConstructL();
    CleanupStack::Pop(); // server

    return server;
}

void CCobainServer::ConstructL()
{
    // start the server
    StartL(KCobainServerName);

    Log::Print(_L("** server constructed"));
}

CSharableSession* CCobainServer::NewSessionL(const TVersion &aVersion) const
{
    // verify version
    if( !User::QueryVersionSupported(TVersion(KCobainServerMajorVersion,
                          KCobainServerMinorVersion,
                          KCobainServerBuildVersion),
                     aVersion) ) {
        User::Leave(KErrNotSupported);
    }

    RThread client = Message().Client();
    CServerSession *session =
        CServerSession::NewL(client, 
                             const_cast<CCobainServer*>(this)/*,
                             iSubsessionContainerIndex->CreateL()*/);

    return session;
}

void CCobainServer::IncrementSession()
{
    iSessionCount++;
}

void CCobainServer::DecrementSession()
{
    iSessionCount--;

    if (iSessionCount < 1)
    {
        // stopping server will delete server
        CActiveScheduler::Stop();
    }
}

void CCobainServer::PanicServer(CCobainServer::TServerPanic aPanic)
{
    User::Panic(KServerPanic, aPanic);
}

void CCobainServer::ThreadFunctionL()
{
    CActiveScheduler* activeScheduler = CActiveScheduler::Current();

    if( activeScheduler == NULL ) 
    {
        activeScheduler = new (ELeave) CActiveScheduler();
        CleanupStack::PushL(activeScheduler) ;
    
        CActiveScheduler::Install(activeScheduler);
    }
    
    CCobainServer *server = CCobainServer::NewL();
    CleanupStack::PushL(server);

    RSemaphore semaphore;
    User::LeaveIfError(semaphore.OpenGlobal(KCobainServerSemaphoreName));

    semaphore.Signal();
    semaphore.Close();

    // blocks until CActiveScheduler::Stop() is invoked
    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy(2); // server, activeScheduler
}

TInt CCobainServer::ThreadFunction(TAny* /*aNone*/)
{
    CTrapCleanup* cleanupStack = CTrapCleanup::New();
    if( cleanupStack == NULL )
    {
        PanicServer(CCobainServer::EServerStartFailed);
    }
  
    TRAPD(err, ThreadFunctionL());
    if( err != KErrNone )
    {
        RDebug::Print(_L("The server thread has left the building! err = %d"), err);
        PanicServer(CCobainServer::EServerStartFailed);
    }

    delete cleanupStack;

    return KErrNone;
}

#ifdef __WINS__     // simulator environment builds

IMPORT_C TInt WinsMain();
EXPORT_C TInt WinsMain()
{
    return reinterpret_cast<TInt>(&CCobainServer::ThreadFunction);
}

GLDEF_C TInt E32Dll(TDllReason)
{
    return KErrNone;
}

#else               // target machine builds

TInt E32Main()
{
    return CCobainServer::ThreadFunction(NULL);
}

#endif

---