/*
 * Copyright (c) 2010 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:  Implementation of CFlexTimerServer class.
 *
 */
/*
 * %version: 2 %
 */

// System include files
#include <e32cmn.h>
#include <e32std.h>
// User include files go here:
#include "flextimercommon.h"
#include "flextimerserver.h"
#include "flextimersession.h"
#include "flextimerengine.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "flextimerserverTraces.h"
#endif

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

// --------------------------------------------------------------------------
// Two phased construction, 1st phase
// --------------------------------------------------------------------------
//
EXPORT_C CFlexTimerServer* CFlexTimerServer::NewL(
        CActive::TPriority aPriority )
    {
    CFlexTimerServer* self = new ( ELeave ) CFlexTimerServer( aPriority );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// Destructor
// --------------------------------------------------------------------------
//
CFlexTimerServer::~CFlexTimerServer()
    {
    // Free allocated resources, CServer2 shutdowns sessions
    delete iTimerEngine;

    OstTrace0( TRACE_INTERNAL,
            CFLEXTIMERSERVER_DEL,
            "CFlexTimerServer::~CFlexTimerServer: exiting" );
    }

// --------------------------------------------------------------------------
// Creation of new sessions, called by server framework
// --------------------------------------------------------------------------
//
CSession2* CFlexTimerServer::NewSessionL( const TVersion& aVersion,
                                          const RMessage2& /*aMessage*/ ) const
    {
    // Version checking, according to two main principles
    // 1. Newer server will always support older clients (change this if
    //    compatibility is changed at some phase)
    // 2. Guaranteed that newer client will be compatible with older server 
    //    within the same major version
    if ( aVersion.iMajor > KFlexTimerServMajorVersionNumber )
        {
        OstTrace1(
                TRACE_INTERNAL,
                CFLEXTIMERSERVER_NEWSESSIONLVER,
                "CFlexTimerServer::NewSessionL: Invalid major version (%d)",
                aVersion.iMajor );
        User::Leave( KErrNotSupported );
        }

    // Create and return session
    CSession2* session = new ( ELeave ) CFlexTimerSession( iTimerEngine );

    OstTrace1( TRACE_INTERNAL,
            CFLEXTIMERSERVER_NEWSESSIONL,
            "CFlexTimerServer::NewSessionL: Created; session=%x",
            ( TUint )session );

    return session;
    }

// --------------------------------------------------------------------------
// Thread start function, loops in active scheduler
// --------------------------------------------------------------------------
//
void CFlexTimerServer::StartServerL()
    {
    // Called when thread is created, create active scheduler
    CActiveScheduler* sched = new CActiveScheduler;
    if ( sched == NULL )
        {
        // Leave error code is used as a panic code
        User::Leave( EFlexTimerServerActiveScheduler );
        }
    // Add active scheduler object to cleanup stack before installing it.
    // It will be deleted, if any of the next operations fails.
    CleanupStack::PushL( sched );
    CActiveScheduler::Install( sched );

    // Create server object and start it
    CFlexTimerServer* flexServer = NULL;
    flexServer = CFlexTimerServer::NewL( EPriorityStandard );

    // Push the server object to cleanup stack before starting it
    CleanupStack::PushL( flexServer );
    
    TInt err = KErrNone;
    
    err = flexServer->Start( KFlexTimerServerName );
    if ( err != KErrNone )
        {
        // Leave error code is used as a panic code
        User::Leave( EFlexTimerServerStartServer );
        }

    // Complete open rendezvous in this process (syncs with creator)
    RProcess::Rendezvous( KErrNone );

    // Active scheduler start will not leave, thus pop added objects
    // from the cleanup stack. They will be deleted once the execution
    // returns from the active scheduler (application is exiting)
    CleanupStack::Pop( flexServer );
    CleanupStack::Pop( sched );

    OstTrace0( TRACE_INTERNAL,
            CFLEXTIMERSERVER_START,
            "CFlexTimerServer::StartServerL: Call ActiveScheduler" );

    // Start active scheduler, thread stays in active scheduler loop
    CActiveScheduler::Start();

    OstTrace0( TRACE_INTERNAL,
            CFLEXTIMERSERVER_EXIT,
            "CFlexTimerServer::StartServerL: ActiveScheduler exit" );

    // Delete allocated resources
    delete flexServer;
    delete sched;
    }

// --------------------------------------------------------------------------
// Constructor
// --------------------------------------------------------------------------
//
CFlexTimerServer::CFlexTimerServer( CActive::TPriority aPriority ) :
    CServer2( aPriority ), iTimerEngine( NULL )
    {

    }

// --------------------------------------------------------------------------
// Two phased construction, 2nd phase
// --------------------------------------------------------------------------
//
void CFlexTimerServer::ConstructL()
    {
    // Create engine, leaving is handled in server creation
    iTimerEngine = CFlexTimerEngine::NewL();
    OstTrace0( TRACE_INTERNAL,
            CFLEXTIMERSERVER_CONSTRUCTL,
            "CFlexTimerServer::ConstructL: Created engine" );
    }

// ======== GLOBAL FUNCTIONS ========

// --------------------------------------------------------------------------
// Main function of the server executable.
// --------------------------------------------------------------------------
//
GLDEF_C TInt E32Main()
    {
    // Mark memory allocation check 
    __UHEAP_MARK;

    // Create cleanup stack
    CTrapCleanup* cleanup = CTrapCleanup::New();
    __ASSERT_ALWAYS( cleanup, User::Panic( KFlexTimerServerPanicCat,
                    EFlexTimerServerCleanupStack ) );
    // Start server
    TRAPD( panicCode, CFlexTimerServer::StartServerL() );
    if ( panicCode != KErrNone )
        {
        OstTrace1( TRACE_INTERNAL,
                CFLEXTIMERSERVER_MAINERROR,
                "CFlexTimerServer - Main: Start server failed (%d)",
                panicCode );
        delete cleanup;
        User::Panic( KFlexTimerServerPanicCat, panicCode );
        }
    else
        {
        OstTrace0( TRACE_INTERNAL,
                CFLEXTIMERSERVER_MAINEXIT,
                "CFlexTimerServer - Main: Application exiting" );

        // Delete cleanup stack
        delete cleanup;
        }

    // Memory allocation check, panic in UDEB case of memory leak
    __UHEAP_MARKEND;

    return KErrNone;
    }