/*

* Copyright (c) 2002-2007 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:  CFServer class implementation.

*

*/

#include <e32svr.h>

#include <ecom/ecom.h>

#include "CFServer.h"

#include "CFEngine.h"

#include "cftrace.h"

#include "cfutils.h"

#include "cfcommon.h"

// CONSTANTS

/**

* Enable file trace macros

*/

#ifdef TRACE_INTO_FILE

#include <f32file.h>

    /**

    * Enables logging by creating the log folder.

    */

    LOCAL_C void EnableLog()

        {

        RFs fs;

        if( fs.Connect() == KErrNone )

            {

            fs.MkDirAll( KFullPath );

            fs.Close();

            }

        }

    #define ENABLE_LOG\

        {\

        EnableLog();\

        }

#else//TRACE_INTO_FILE not defined

    #define ENABLE_LOG

#endif//TRACE_INTO_FILE

// MEMBER FUNCTIONS

CCFServer* CCFServer::NewL()

    {

    FUNC_LOG;

    CCFServer* self = CCFServer::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

CCFServer* CCFServer::NewLC()

    {

    FUNC_LOG;

    CCFServer* self = new( ELeave ) CCFServer( EPriorityNormal );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CCFServer::~CCFServer()

    {

    FUNC_LOG;

    delete iCFEngine;

    // Call this from here to ease testing of other components

    REComSession::FinalClose();

    }

void CCFServer::ConstructL()

    {

    FUNC_LOG;

    // Rename cfw thread

    User::RenameThread( KContextServerName );

    iCFEngine = CCFEngine::NewL( *this );

    // Start server

    StartL( KContextServerName );

    }

CCFServer::CCFServer( TInt aPriority ):

    CServer2( aPriority )

    {

    FUNC_LOG;

    }

// METHODS

//----------------------------------------------------------------------------

// CCFServer::NewSessionL

//----------------------------------------------------------------------------

//

CSession2* CCFServer::NewSessionL(

    const TVersion &aVersion,

    const RMessage2& /*aMessage*/) const

    {

    FUNC_LOG;

    // check we're the right version

    TVersion version( KContextServMajorVersionNumber,

        KContextServMinorVersionNumber,

        KContextServBuildVersionNumber);

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

        {

        User::Leave(KErrNotSupported);

        }

    CSession2* session = CCFServSession::NewL( 

    	( MCFExtendedContextInterface& )*iCFEngine,

        ( MCFActionInterface& )*iCFEngine,

        ( MCFScriptInterface& )*iCFEngine );

    // make new session

    return session;

    }

//----------------------------------------------------------------------------

// CCFServer::NewSessionL

//----------------------------------------------------------------------------

//

TBool CCFServer::CheckClientSecurity( const RThread& aClientThread,

	const TSecurityPolicy& aSecurityPolicy )

	{

    FUNC_LOG;

    // Security check only needed if request is from other process than CF

    TBool securityPassed = ETrue;

    if( !CFUtils::RequestFromSameProcess( aClientThread ) )

        {

        securityPassed = aSecurityPolicy.CheckPolicy( aClientThread );

        }

    return securityPassed;

	}

//----------------------------------------------------------------------------

// CCFServer::PanicServer

//----------------------------------------------------------------------------

//

void CCFServer::PanicServer( TContextServPanic aPanic )

    {

    FUNC_LOG;

    User::Panic( KContextServerName, aPanic );

    }

//----------------------------------------------------------------------------

// CCFServer::ThreadFunctionL

//----------------------------------------------------------------------------

//

void CCFServer::ThreadFunctionL( TAny* /*aThreadParms*/ )

    {

    FUNC_LOG;

    // Create scheduler

    CActiveScheduler* activeScheduler = new( ELeave ) CActiveScheduler;

    CleanupStack::PushL( activeScheduler );

    CActiveScheduler::Install( activeScheduler );

    // Create Context Framework Server and signal client that we are ready

    CCFServer* server = CCFServer::NewLC();

    RProcess::Rendezvous( KErrNone );

    TIMESTAMP( "CF server active scheduler start" );

    // Start scheduler

    CActiveScheduler::Start();

    TIMESTAMP( "CF server process exit" );

    // Clean up

    CleanupStack::PopAndDestroy( server );

    CleanupStack::PopAndDestroy( activeScheduler );

    }

//----------------------------------------------------------------------------

// CCFServer::ThreadFunction

//----------------------------------------------------------------------------

//

TInt CCFServer::ThreadFunction( TAny* aThreadParms )

    {

    FUNC_LOG;

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if( cleanupStack )

        {

        TRAPD( err, ThreadFunctionL( aThreadParms ) );

        if( err != KErrNone )

            {

            // Signal client that server creation failed

            RProcess::Rendezvous( err );

            }

        }

    // Clean up        

    delete cleanupStack;

    cleanupStack = NULL;

    return KErrNone;

    }

// Entry point

GLDEF_C TInt E32Main()

	{

	ENABLE_LOG;

    HEAP( "[START] CF server process entry" );

    TIMESTAMP( "CF server process entry" );

	return CCFServer::ThreadFunction( NULL );

	}