/*

* Copyright (c) 2009 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: This file contains the implementation of the

*              CHtiBtCommServer class.

*              CHtiBtCommServer handles Symbian server side operations

*              such as server starting and client session creation.

*

*/

// INCLUDE FILES

#include "HtiBtClientServerCommon.h"

#include "HtiBtCommServer.h"

#include "HtiBtCommServerSession.h"

#include "Logger.h"

#include <e32base.h>

#include <e32std.h>

#include <e32svr.h>

#include <e32uid.h>

// CONSTANTS

// For memory allocations

const TUint KBtCommServerHeapSizeMin       = 0x6000;

const TUint KBtCommServerHeapSizeMax       = 0x20000;

const TUint KBtCommServerStackSize         = 0x8000;

//*****************************************************************************

//

// Class CHtiBtCommServer

//

//*****************************************************************************

/*---------------------------------------------------------------------------*/

CHtiBtCommServer::CHtiBtCommServer( TInt aPriority )

    : CServer2( aPriority, ESharableSessions )

    {

    LOGFW(DebugLog(_L("CHtiBtCommServer: CHtiBtCommServer()")))

    __DECLARE_NAME(_S( "CHtiBtCommServer" ));

    }

/*---------------------------------------------------------------------------*/

void CHtiBtCommServer::ConstructL()

    {

    LOGFW(DebugLog(_L("CHtiBtCommServer: ConstructL()")))

    }

/*---------------------------------------------------------------------------*/

CHtiBtCommServer* CHtiBtCommServer::NewL()

    {

    LOGFW(DebugLog(_L("CHtiBtCommServer: NewL()"));)

    CHtiBtCommServer *pS =

        new (ELeave) CHtiBtCommServer( EBtCommServerPriority );

    CleanupStack::PushL( pS );

    __ASSERT_ALWAYS( pS != NULL, PanicServer( ESvrCreateServer ) );

    pS->ConstructL();

    CleanupStack::Pop( pS );

    User::SetProcessCritical( User::ENotCritical );

    User::SetCritical( User::ENotCritical );

    LOGFW(InfoLog(_L("Server was started")))

    return pS;

    }

/*---------------------------------------------------------------------------*/

CHtiBtCommServer::~CHtiBtCommServer()

    {

    LOGFW(DebugLog(_L("CHtiBtCommServer: ~CHtiBtCommServer()")))

    }

/*---------------------------------------------------------------------------*/

void CHtiBtCommServer::SessionFreed()

    {

    LOGFW(DebugLog(_L("CHtiBtCommServer: SessionFreed(): Stopping active scheduler"));)

    iSession = NULL; // iSession is owned by server framework, not deleted here

    CActiveScheduler::Stop();

    LOGFW(DebugLog(_L("CHtiBtCommServer: SessionFreed(): Done"));)

    }

/*---------------------------------------------------------------------------*/

void CHtiBtCommServer::SessionCreated( CHtiBtCommServerSession* aSession )

    {

    LOGFW(DebugLog(_L("CHtiBtCommServer: SessionCreated()"));)

    iSession = aSession;

    }

/*---------------------------------------------------------------------------*/

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

    const RMessage2& aMessage ) const

    {

    LOGFW(DebugLog(_L("CHtiBtCommServer: NewSessionL() - IPC V2"));)

    aMessage.IsNull();

    if ( iSession )

        User::Leave( KErrAlreadyExists ); // Allow only one session

    // Check that server is the right version

    TVersion ver( KBtCommServerMajorVersionNumber,

                  KBtCommServerMinorVersionNumber,

                  KBtCommServerBuildVersionNumber );

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

        {

        User::Leave( KErrNotSupported );

        }

    return CHtiBtCommServerSession::NewL( (CHtiBtCommServer*)this );

    }

/*---------------------------------------------------------------------------*/

GLDEF_C TInt CHtiBtCommServer::ThreadFunction( TAny* anArg )

    {

    LOGFW(_L("CHtiBtCommServer: ThreadFunction(): Starting"));

    __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    // Convert argument into semaphore reference

    RSemaphore& semaphore = *(RSemaphore*)anArg;

    // Start scheduler...

    LOGFW(DebugLog(_L("CHtiBtCommServer: ThreadFunction(): Installing active scheduler"));)

    CActiveScheduler *pA = new CActiveScheduler;

    __ASSERT_ALWAYS( pA != NULL, PanicServer( EMainSchedulerError ) );

    CActiveScheduler::Install( pA );

    CHtiBtCommServer* pS = NULL;

    TRAPD(err,

        // ...and server

        LOGFW(DebugLog(_L("CHtiBtCommServer: ThreadFunction(): Creating server instance"));)

        pS = CHtiBtCommServer::NewL();

        )

    if ( err != KErrNone )

        {

        LOGFW(DebugLog(_L("CHtiBtCommServer: ThreadFunction(): Failed creating server instance"));)

        }

    LOGFW(DebugLog(_L("CHtiBtCommServer: ThreadFunction(): Starting server"));)

    __ASSERT_ALWAYS( pS->Start(KBtCommServerName) == KErrNone,

        PanicServer( ESvrStartServer ) ); // Make first request pending,

    // Signal that server has started

    LOGFW(DebugLog(_L("CHtiBtCommServer: ThreadFunction(): Signalling client: server is up and running"));)

    semaphore.Signal();

    LOGFW(DebugLog(_L("CHtiBtCommServer: ThreadFunction(): Waiting for server's death"));)

    // Start receiving requests from clients

    CActiveScheduler::Start();

    LOGFW(DebugLog(_L("CHtiBtCommServer: ThreadFunction(): Server was stopped"));)

    LOGFW(InfoLog(_L("Server was stopped")))

    delete pS;

    LOGFW(DebugLog(_L("CHtiBtCommServer: ThreadFunction(): Server was deleted"));)

    // Finished

    delete pA;

    pA = NULL;

     // Destroy clean-up stack

    delete cleanup;

    cleanup = NULL;

    __UHEAP_MARKEND;

    return KErrNone;

    }

/*---------------------------------------------------------------------------*/

GLDEF_C void PanicServer( TBtCommServerPanic aPanic )

    {

    LOGFW(DebugLog(_L("CHtiBtCommServer: PanicServer()"));)

    _LIT( KTxtServerPanic, "BtCommServer panic" );

    User::Panic( KTxtServerPanic, aPanic );

    }

/*---------------------------------------------------------------------------*/

EXPORT_C TInt StartThread()

    {

//    LOGFW(_L("CHtiBtCommServer: StartThread()"));

    TInt res = KErrNone;

    // Create server - if one of this name does not already exist

    TFindServer findBtCommServer( KBtCommServerName );

    TFullName name;

    if ( findBtCommServer.Next( name ) != KErrNone ) // Server doesn't exist

        {

         // Create a semaphore to know when thread initialization has finished

        RSemaphore semaphore;

        semaphore.CreateLocal(0);

//        LOGFW(_L("CHtiBtCommServer: Created Semaphore...\n"));

        // Create new server thread and thread's main function

        RThread thread;

        res = thread.Create( KBtCommServerName,

                             CHtiBtCommServer::ThreadFunction,

                             KBtCommServerStackSize,

                             KBtCommServerHeapSizeMin,

                             KBtCommServerHeapSizeMax,

                             &semaphore );

        if ( res == KErrNone ) // Thread created ok - now start it going

            {

//            LOGFW(_L("CHtiBtCommServer: StartThread() - Create OK"));

            thread.SetPriority( EPriorityNormal );

//            TRequestStatus stat1;

//            thread.Logon(stat1);

            thread.Resume();  // Start it going

            semaphore.Wait(); // Wait until it's initialized

            thread.Close();   // No longer interest in the other thread

            }

        else // Thread not created ok

            {

            // No further interest in it

//            LOGFW(_L("CHtiBtCommServer: StartThread() - Create FAIL"));

            thread.Close();

            }

        semaphore.Close();

        }

    return res;

    }

/*---------------------------------------------------------------------------*/

GLDEF_C TInt E32Main()

    {

    return KErrNone;

    }

// End of the file