/*

* Copyright (c) 2003-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:  This module contains the implementation of CCbsServer class 

*                member functions.

*   

*                This file contains the entry point for CbsServer.exe/dll.  

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <barsc.h>

#include "CbsCommon.h"

#include "CCbsScheduler.h"

#include "CbsServerConstants.h"

#include "CbsServerPanic.h"

#include "CCbsServer.h"

#include "CCbsSession.h"

#include "CbsUtils.h"

#include "CCbsRecEtel.h"

#include "CCbsDbImp.H"

#include "CCbsDbImp.H"

#include "CCbsRecEtel.h"

#include "CCbsDbImpSettings.H"

#include "CCbsDbImpTopicList.h"

#include "CCbsReceiverHelper.h"

#include "CCbsSatRefresh.h"

#include <e32property.h>

#include "CbsServerInternalPSKeys.h"

#include "CCbsShutdownMonitor.h"

#include "CbsLogger.h"

#include "CbsServerUid.h"

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void InitServerL();

// ==================== LOCAL FUNCTIONS ====================

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

// InitServerL

// Initializes and starts CBS Server.

// Creates the active scheduler and an instance of the server.

// Returns: None

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

//

LOCAL_C void InitServerL()

    {

    CBSLOGSTRING("CBSSERVER: >>> InitServerL()");

    // perform init code under the cleanup stack

	User::RenameThread( KCbsServerName );

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

    TFindServer findCbsServer( KCbsServerName );

    TFullName pathName;

    RMutex serverStartMutex;

    TInt createErr( serverStartMutex.CreateGlobal( _L("CBSSERVERMTX") ) );

    if ( createErr )

        {

        TInt openErr( serverStartMutex.OpenGlobal( _L("CBSSERVERMTX") ) );

        User::LeaveIfError( openErr );

        }

    serverStartMutex.Wait();

    if ( findCbsServer.Next( pathName ) != KErrNone ) 

        {

        // start scheduler and server

        CCbsScheduler* scheduler = new (ELeave) CCbsScheduler;

        CleanupStack::PushL( scheduler );

        CActiveScheduler::Install( scheduler );

        CCbsServer* server = CCbsServer::NewL();

        CleanupStack::PushL( server );

        // The scheduler needs access to the server instance.

        scheduler->SetServer( server );

        // Set the key using Publish & Subscribe

        RProperty property;                       

        _LIT_SECURITY_POLICY_PASS( KCbsServerReadPolicy );

        _LIT_SECURITY_POLICY_S0( KCbsServerWritePolicy, KCbsServerUid3 );

        property.Define( KPSUidCellBroadcast, KCbsServerStarted, RProperty::EInt, KCbsServerReadPolicy, KCbsServerWritePolicy );

        CBSLOGSTRING("CBSSERVER: InitServerL(): Property defined.");

        property.Set( KPSUidCellBroadcast, KCbsServerStarted, 1 );

        CBSLOGSTRING("CBSSERVER: InitServerL(): Property set.");

        property.Close();

        serverStartMutex.Signal();

        serverStartMutex.Close();

        CBSLOGSTRING("CBSSERVER: InitServerL(): CbsServer created ok, starting active schduler.");

        RProcess::Rendezvous( KErrNone );

        // start fielding requests from clients

        CActiveScheduler::Start();

        CBSLOGSTRING("CBSSERVER: InitServerL(): CbsServer shutting down, destroying scheduler & server instances.");

        // finished when the scheduler stops

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

        }

    else

        {

        serverStartMutex.Signal();

        serverStartMutex.Close();

        }

    CBSLOGSTRING("CBSSERVER: <<< InitServerL()");

    }

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

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

// CCbsServer::CCbsServer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCbsServer::CCbsServer( 

    TInt aPriority )

    : CServer2( aPriority )

    {

    }

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

// CCbsServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCbsServer::ConstructL()

    {

    CBSLOGSTRING( "CBSSERVER: >>> CCbsServer::ConstructL()" );

    // Use PubSub to monitor shutdown event

    iShutdownMonitor = CCbsShutdownMonitor::NewL( *this );

    iReceiver = CCbsRecEtel::NewL();

    iDatabase = CCbsDbImp::NewL();

    iHelper = CCbsReceiverHelper::NewL( *iDatabase );

    iReceiver->SetInterface( iHelper );

    InitReceiverL();

    // Create the container index.

    iContainerIx = CObjectConIx::NewL();

    iContainer = NewContainerL();

    iIndex = CObjectIx::NewL();

	// Create SAT refresh listener

	TInt error( KErrNone );

	TRAP( error, iSatRefresh = CCbsSatRefresh::NewL( *this ));

    CBSLOGSTRING2( "CBSSERVER: CCbsServer::ConstructL(): CCbsSatRefresh::NewL error: %d", error );

    // Start the server

    if ( Start( KCbsServerName ) != KErrNone ) 

        {

        CbsServerPanic( ECbsServerStartFailed );

        }

    CBSLOGSTRING( "CBSSERVER: <<< CCbsServer::ConstructL()" );

    }

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

// CCbsServer::NewL

// Two-phased constructor.

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

//

CCbsServer* CCbsServer::NewL()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsServer::NewL()");

    CCbsServer* self = new ( ELeave ) CCbsServer( KCbsServerPriority );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    CBSLOGSTRING("CBSSERVER: <<< CCbsServer::NewL()");

    return self;

    }

// Destructor

CCbsServer::~CCbsServer()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsServer::~CCbsServer()");

    // Note: it is important to delete in correct order

    // The correct order is: 

    //        1st:    sessions, subsessions and other server related objects

    //        2nd:    receiver 

    //        3rd:    database

    if ( iIndex )

        {

        delete iIndex; 

        iIndex = NULL;        

        }

    if ( iContainer )

        {

        if ( iContainerIx )

            {

            iContainerIx->Remove( iContainer );

            iContainer = NULL;

            }        

        }

    // Delete subsessions

    if ( iContainerIx )

        {

        delete iContainerIx;

        iContainerIx = NULL;

        }    

    if ( iSatRefresh )

        {

        delete iSatRefresh;

        iSatRefresh = NULL;

        }

    if ( iReceiver )

        {

        delete iReceiver;

        iReceiver = NULL;

        }	

    if ( iDatabase )

        {

        delete iDatabase;

        iDatabase = NULL;

        }

    if ( iHelper )

        {

        delete iHelper;

        iHelper = NULL;

        }

    if ( iShutdownMonitor )

        {

        delete iShutdownMonitor;

        iShutdownMonitor = NULL;

        }

    CBSLOGSTRING("CBSSERVER: <<< CCbsServer::~CCbsServer()");

    }

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

// CCbsServer::NewSessionL

// Creates a new session (an instance of CCbsSession).

//   

// The method is meant to be called by the Symbian OS server framework and 

// so it should not be used in any other case.

//  

// The method leaves if the version given as parameter and the server

// version differ.

// (other items were commented in a header).

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

//

CSession2* CCbsServer::NewSessionL( 

    const TVersion& aVersion,

    const RMessage2& /*aMessage*/ ) const

    {

    TVersion currentVersion( KCbsServerVersionMajor,

                             KCbsServerVersionMinor,

                             KCbsServerVersionBuild );

    // Check the client version

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

        {

        User::Leave( KErrNotSupported );

        }

    // Create and return a new session

    return CCbsSession::NewL( *( CCbsServer* ) this );

    }

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

// CCbsServer::NewContainerL

// Creates a new session object container.

//  

// It is the responsibility of the caller to delete the object 

// container, when it is no longer used.

// (other items were commented in a header).

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

//

CObjectCon* CCbsServer::NewContainerL()

    {

    // Create the new container.

    return iContainerIx->CreateL();

    }

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

// CCbsServer::Database

// Returns a reference to the database.

// (other items were commented in a header).

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

// 

CCbsDbImp& CCbsServer::Database()

    {

    return *iDatabase;

    }

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

// CCbsServer::Receiver

// Returns a reference to the receiver.

// (other items were commented in a header).

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

//

CCbsRecEtel& CCbsServer::Receiver()

    {

    return *iReceiver;

    }

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

// CCbsServer::TotalTopicsDetected

// Returns the total number of detected (via topic detection feature)

// topics and then clears the counter.

// (other items were commented in a header).

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

//   

TInt CCbsServer::TotalTopicsDetected()

    {

    TInt count( iHelper->TopicsDetected() );

    iHelper->ClearTopicsDetectedCounter();

    return count;

    }

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

// CCbsServer::PanicClient

// Panics the client.

// (other items were commented in a header).

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

//  

void CCbsServer::PanicClient( 

    TInt aPanic ) const

    {

    __DEBUGGER();   // Debugger breakpoint in server's context.

    Message().Panic( KCbsServerName, aPanic );

    }

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

// CCbsServer::Shutdown

// Shuts down the server.

// (other items were commented in a header).

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

// 

void CCbsServer::Shutdown()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsServer::Shutdown()");

    Cancel();

    CActiveScheduler::Stop();

    CBSLOGSTRING("CBSSERVER: <<< CCbsServer::Shutdown()");

    }

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

// CCbsServer::ContainerIndex

// Returns the container index.

// (other items were commented in a header).

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

// 

CObjectConIx& CCbsServer::ContainerIndex()

    {

    return *iContainerIx;

    }

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

// CCbsServer::ServerMessage

// Returns the current IPC message.

// (other items were commented in a header).

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

// 

const RMessage2 CCbsServer::ServerMessage() const

    {

    return Message();

    }

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

// CCbsServer::ReturnObjectByHandle

// Returns a subsession object matching the given handle.

// (other items were commented in a header).

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

//

CCbsObject* CCbsServer::ReturnObjectByHandle( 

    TUint aHandle )

    {

    return ( CCbsObject* )iIndex->At( aHandle );

    }

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

// CCbsServer::DeleteObjectByHandle

// Deletes a subsession 

// (other items were commented in a header).

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

//

void CCbsServer::DeleteObjectByHandle( 

    TUint aHandle )

    {    

    // Find object and then delete it

    CCbsObject* object = ReturnObjectByHandle( aHandle );

    if ( object )

        {

        // Remove from index (and it will delete the object)

        iIndex->Remove( aHandle );

        }

    else

        {

        CbsServerPanic( EInvalidSessionObject );

        }

    }

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

// CCbsServer::Container

// Returns the object container

// (other items were commented in a header).

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

//

CObjectCon& CCbsServer::Container()

    {

    return *iContainer;

    }

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

// CCbsServer::ObjectIx

// Returns the object index

// (other items were commented in a header).

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

//

CObjectIx& CCbsServer::ObjectIx()

    {

    return *iIndex;

    }

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

// CCbsServer::InitReceiverL

// Initializes the receiver with values retrieved from the database.

// (other items were commented in a header).

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

// 

void CCbsServer::InitReceiverL()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsServer::InitReceiverL()");

    // DB leave trapped.

    TInt ignore( KErrNone );

    TRAP( ignore, iReceiver->LoadSimTopicsL() );

    CBSLOGSTRING2("CBSSERVER: CCbsServer::InitReceiverL(): LoadSimTopicsL() TRAPped error: %d", ignore);

    iReceiver->ApplyStateChangesL();

    CBSLOGSTRING("CBSSERVER: <<< CCbsServer::InitReceiverL()");    

    }

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

// CCbsServer::ReLoadSimTopicsL

// Initializes the receiver with values retrieved from the database.

// (other items were commented in a header).

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

// 

void CCbsServer::ReLoadSimTopicsL()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsServer::ReLoadSimTopicsL()");

    TInt ignore( KErrNone );

    TRAP( ignore, iReceiver->LoadSimTopicsL() );

    CBSLOGSTRING2("CBSSERVER: CCbsServer::ReLoadSimTopicsL(): LoadSimTopicsL() TRAPped error: %d", ignore);

    iReceiver->ApplyStateChangesL();

    CBSLOGSTRING("CBSSERVER: <<< CCbsServer::ReLoadSimTopicsL()");    

    }    

// ================= OTHER EXPORTED FUNCTIONS ==============

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

// E32Main

// E32Main implements the executable entry function.

// Creates a cleanup stack and runs the server. 

// Returns: Zero

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

//

GLDEF_C TInt E32Main()

    {

    __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New(); 

    TRAPD( error, InitServerL() ); 

    __ASSERT_ALWAYS( !error, User::Panic( KCbsServerName, error) );

    delete cleanup; 

    __UHEAP_MARKEND;

    return 0; 

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File