/*

* Copyright (c) 2007-2008 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:  Server source file

*

*/

// INCLUDE FILES

#include <centralrepository.h>

#include <startupreason.h>

#include <starterdomaincrkeys.h>

#include "IntegrityCheckServer.h"

#include "IntegrityCheckDefs.h"

#include "IntegrityCheckDebug.h"

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// RunServerL

//

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

static void RunServerL()

    {

    BTIC_TRACE_PRINT("[BTIC Server] RunServerL");

    User::LeaveIfError( RThread::RenameMe(KIntecrityCheckServerName) );

    // Create and install the active scheduler

    CActiveScheduler* scheduler = new ( ELeave ) CActiveScheduler;   

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    // Create server

    CIntegrityCheckServer::NewLC();

    // Initialisation complete

    RProcess::Rendezvous( KErrNone );

    BTIC_TRACE_PRINT("[BTIC Server] RunServerL: CActiveScheduler::Start");

    // Start active scheduler

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( 2 ); // scheduler, CIntegrityCheckServer

    }

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

// E32Main()

//

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

//

GLDEF_C TInt E32Main()

    {

    __UHEAP_MARK;

    BTIC_TRACE_PRINT("[BTIC Server] E32Main");

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if ( cleanup == NULL )

        {

        return KErrNoMemory;

        }

    TRAPD( err, RunServerL() );

    __ASSERT_ALWAYS( !err, User::Panic( KIntecrityCheckServerText, err ) );

    delete cleanup;

    __UHEAP_MARKEND;

    return KErrNone;

    }

//======================== CIntegrityCheckServer =============================

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

// CIntegrityCheckServer::CIntegrityCheckServer

//

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

//

CIntegrityCheckServer::CIntegrityCheckServer()

    :CPolicyServer( 0, CPPolicy, ESharableSessions )

    {

    }

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

// CIntegrityCheckServer::NewLC

//

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

//

CServer2* CIntegrityCheckServer::NewLC()

    {

    CIntegrityCheckServer* self = new ( ELeave ) CIntegrityCheckServer;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CIntegrityCheckServer::ConstructL

//

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

//

void CIntegrityCheckServer::ConstructL()

    {

    BTIC_TRACE_PRINT("[BTIC Server] ConstructL");

    iSessionCount = 0;

    StartL( KIntecrityCheckServer );    

    iShutDown.ConstructL();

    BTIC_TRACE_PRINT("[BTIC Server] ConstructL: Start shutdown timer");

    iShutDown.Start();    

    }

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

// CIntegrityCheckServer::NewSessionL

//

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

//

CSession2* CIntegrityCheckServer::NewSessionL(

    const TVersion&,

    const RMessage2&) const

    {

    BTIC_TRACE_PRINT("[BTIC Server] NewSessionL");

    return new (ELeave) CIntegrityCheckSession();

    }

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

// CIntegrityCheckServer::AddSession()

// Cancel the shutdown timer now, the new session is connected

//

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

//

void CIntegrityCheckServer::AddSession()

    {

    BTIC_TRACE_PRINT("[BTIC Server] AddSession");

    iSessionCount++;

    BTIC_TRACE_PRINT("[BTIC Server] Cancel shutdown timer");

    iShutDown.Cancel();  // Cancel any outstanding shutdown timer    

    }

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

// CIntegrityCheckServer::RemoveSession

// Decrement the session counter and start the shutdown timer if the last client

// has disconnected

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

//

void CIntegrityCheckServer::RemoveSession()

    {

    BTIC_TRACE_PRINT("[BTIC Server] RemoveSession");

    BTIC_TRACE_PRINT_NUM("[BTIC Server] Session count = %d", iSessionCount );

    if ( --iSessionCount == 0 )

        {      

        BTIC_TRACE_PRINT("[BTIC Server] Remove session and shutdown ");

        iShutDown.Start();

        }

    }

//======================== CIntegrityCheckSession ============================

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

// CIntegrityCheckSession::CIntegrityCheckSession

//

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

//

CIntegrityCheckSession::CIntegrityCheckSession()

    {    

    }

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

// CIntegrityCheckSession::CreateL

// Called by the CServer2

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

//

void CIntegrityCheckSession::CreateL()

    {

    BTIC_TRACE_PRINT("[BTIC Srv session] CIntegrityCheckSession");

    CIntegrityCheckServer* server( static_cast<CIntegrityCheckServer*>

            ( const_cast<CServer2*>( CSession2::Server() ) ) );    

    // Ok we have client so let's cancel shutdown timer.

    server->AddSession();    

    }

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

// CIntegrityCheckSession::~CIntegrityCheckSession

//

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

//

CIntegrityCheckSession::~CIntegrityCheckSession()

    {

    BTIC_TRACE_PRINT("[BTIC Srv session] ~CIntegrityCheckSession");

    CIntegrityCheckServer* server( static_cast<CIntegrityCheckServer*>

            ( const_cast<CServer2*>( CSession2::Server() ) ) );

    server->RemoveSession();

    }

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

// CIntegrityCheckSession::Disconnect

//

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

//

void CIntegrityCheckSession::Disconnect( const RMessage2 &aMessage )

    {

    BTIC_TRACE_PRINT("[BTIC Srv session] Disconnect");    

    CSession2::Disconnect( aMessage );

    }

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

// CIntegrityCheckSession::ServiceL

//

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

//

void CIntegrityCheckSession::ServiceL(const RMessage2& aMessage)

    {

    BTIC_TRACE_PRINT("[BTIC Srv session] ServiceL");

    switch ( aMessage.Function() )

        {

        case EBTICBootReasonSW:

            {            

            TRAPD( err, GetSWBootReasonL( aMessage ) );

            aMessage.Complete( err );

            break;

            }

        default:      

            aMessage.Complete( KErrGeneral );

            break;

        }

    }

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

// CIntegrityCheckSession::ServiceError

//

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

//

void CIntegrityCheckSession::ServiceError( 

    const RMessage2& aMessage,

    TInt aError )

    {

    BTIC_TRACE_PRINT("[BTIC Srv session] ServiceError");

    CSession2::ServiceError( aMessage, aError );

    }

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

// CIntegrityCheckSession::GetSWBootReasonL

//

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

//

void CIntegrityCheckSession::GetSWBootReasonL( const RMessage2& aMessage )

    {  

    BTIC_TRACE_PRINT("[BTIC Srv session] GetSWBootReasonL");  

    // Get sw boot reason from system.   

    TInt bootReason = KErrNone;     

    TInt startupReason = KErrNone;

    CRepository* repository( NULL );

    BTIC_TRACE_PRINT("[BTIC Srv session] Get startup reason from CRepository");

    TInt err = KErrNone;

    TRAP( err, repository = CRepository::NewL( KCRUidStartup ) );

    BTIC_TRACE_PRINT_NUM("[BTIC Srv session] CRepository TRAPD Err = %d", err );

    if ( err == KErrNone )

        {

        CleanupStack::PushL( repository );

        err = repository->Get( KStartupReason, startupReason );        

        BTIC_TRACE_PRINT_NUM("[BTIC Srv session] CRepository Get Err = %d", err );

	    if ( err == KErrNone )

		   {

		   BTIC_TRACE_PRINT_NUM("Returned startup reason: %d ",startupReason );

            if ( startupReason == EDeepRFSReset )

			    {

			     // C drive will be formatted, so let's stop checking.

			     bootReason = EBTICRestoreFactorySetDeep;

			     BTIC_TRACE_PRINT("[BTIC Srv session] Startup reason is FORMAT");

			     }

            else

                {

                // All other reasons are "normal" boot for BTIC.

                bootReason = EBTICNormalBoot;

                BTIC_TRACE_PRINT("[BTIC Srv session] Startup reason is NORMAL");

                }    			    

            }

        else if ( err == KErrNotFound )

            {

            // Reason not found. Propably first boot etc.

            bootReason = EBTICNoSWReason;

            BTIC_TRACE_PRINT("[BTIC Srv session] No SW Startup reason found");            

            }

        else

            {

            // Some other error.

            bootReason = err;

            }                

	    CleanupStack::PopAndDestroy(); //repository    

	    }

    TPckg<TInt> bootReasonValue( bootReason );

    BTIC_TRACE_PRINT("[BTIC Srv session] Write result to client side.");

    // Write boot reason to client side.

    aMessage.WriteL( KParam0, bootReasonValue );      

    }

//============================== CShutdown =====================================

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

// CShutdown::CShutdown

// 

//

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

//

CShutdown::CShutdown():CTimer(-1)

    {

    BTIC_TRACE_PRINT("[BTIC Shutdown] CShutdown: Add scheduler");

    CActiveScheduler::Add(this);

    }

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

// CShutdown::ConstructL

// 

//

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

//

void CShutdown::ConstructL()

    {

    BTIC_TRACE_PRINT("[BTIC Shutdown] ConstructL");

    CTimer::ConstructL();

    }

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

// CShutdown::Start

// Set shutdown timer for server.

//

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

//

void CShutdown::Start()

    {

    BTIC_TRACE_PRINT("[BTIC Shutdown] Start timer");

    After( KServerCloseTime );

    }

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

// CShutdown::RunServerL

// Initiates server exit when the timer expires

//

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

//

void CShutdown::RunL()

    {

    BTIC_TRACE_PRINT("[BTIC Shutdown] RunL: Stop BTIC server");

    CActiveScheduler::Stop();

    }

//EOF