/*
* ============================================================================
*  Name        : btnotifserver.cpp
*  Part of     : bluetoothengine / btnotif
*  Description : Server class for handling commands from clients, and the 
*                central class in btnotif thread.
*
*  Copyright © 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:
*  Nokia Corporation
* ============================================================================
* Template version: 4.1
*/

#include "btnotifserver.h"
#include <btservices/btdevrepository.h>
#include "btnotifsession.h"
#include "btnotifconnectiontracker.h"
#include "btnotifsettingstracker.h"
#include "btnotificationmanager.h"
#include "btnotifdeviceselector.h"
#include "btnotifserversecpolicy.h"
#include "btnotifclientserver.h"

/**  Panic category */
_LIT( KBTNotifPanic, "BTNotif panic" );

/**  Timeout (10 sec) for shutting down the server 
 * (when BT power is off and no clients connected). */
const TInt KBTNtoifShutdownTimeout = 10 * 1000 * 1000;

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

// ---------------------------------------------------------------------------
// Start the server.
// ---------------------------------------------------------------------------
//
static void RunServerL()
    {
    BOstraceFunctionEntry0( DUMMY_DEVLIST );
    
    (void) User::RenameThread( KBTNotifServerName );
    // Create and install the active scheduler for this thread.
    CActiveScheduler* scheduler = new( ELeave ) CActiveScheduler();
    CleanupStack::PushL( scheduler );
    CActiveScheduler::Install( scheduler );
    // create the server (and leave it on the cleanup stack)
    CBTNotifServer* notifServer = CBTNotifServer::NewLC();
    // Initialisation complete, now signal the client
    RProcess::Rendezvous( KErrNone );
        // The server is now up and running.
    BOstrace0( TRACE_NORMAL, DUMMY_DEVLIST, "[BTNOTIF]\t BTNotif server now up and running" );
    // The active scheduler runs during the lifetime of this thread.
    CActiveScheduler::Start();
    // Stopping the active scheduler means terminating the thread.
    // Cleanup the server and scheduler.
    CleanupStack::PopAndDestroy( notifServer );
    CleanupStack::PopAndDestroy( scheduler );
    BOstraceFunctionExit0( DUMMY_DEVLIST );
    }

// ---------------------------------------------------------------------------
// Panic the server.
// ---------------------------------------------------------------------------
//
void PanicServer( TInt aReason )
    {
    User::Panic( KBTNotifPanic, aReason );
    }

// ---------------------------------------------------------------------------
// Panic the client through the client-side message.
// ---------------------------------------------------------------------------
//
void PanicClient( const RMessage2& aMessage, TInt aReason )
    {
    aMessage.Panic( KBTNotifPanic, aReason );
    }

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

// ---------------------------------------------------------------------------
// C++ default constructor
// ---------------------------------------------------------------------------
//
CBTNotifServer::CBTNotifServer()
:   CPolicyServer( EPriorityUserInput, KBTNotifServerPolicy )
    {
    }

// ---------------------------------------------------------------------------
// Symbian 2nd-phase constructor
// ---------------------------------------------------------------------------
//
void CBTNotifServer::ConstructL()
    {
    // Add the server to the active scheduler (from CServer2):
    StartL( KBTNotifServerName );
    iAsyncCb = new( ELeave ) CAsyncCallBack( EPriorityHigh );
    TCallBack cb( AsyncConstructCb, this );
    iAsyncCb->Set( cb );
    iAsyncCb->CallBack();
    }

// ---------------------------------------------------------------------------
// Asynchronous 3rd-phase constructor
// ---------------------------------------------------------------------------
//
void CBTNotifServer::AsyncConstructL()
    {
    iSettingsTracker = CBTNotifSettingsTracker::NewL( this );
    if( iSettingsTracker->GetPowerState() == EBTPowerOn )
        {
        iConnectionTracker = CBTNotifConnectionTracker::NewL( this );
        }
    iNotificationMgr = CBTNotificationManager::NewL( this );
    
    iTimer = CDeltaTimer::NewL(CActive::EPriorityLow);
    TCallBack shutdownCb( ShutdownTimeout, this );
    iShutdownTimerEntry.Set( shutdownCb );
    // The server class does not handle any registry events.
    // Classes that want to receive these events must register
    // via observer interface.
    iDevRep = CBtDevRepository::NewL();
    }

// ---------------------------------------------------------------------------
// Callback for asynchronous construction.
// ---------------------------------------------------------------------------
//
TInt CBTNotifServer::AsyncConstructCb( TAny* aPtr )
    {
    TRAPD( err, ( (CBTNotifServer*) aPtr )->AsyncConstructL() );
    return err;
    }


// ---------------------------------------------------------------------------
// NewLC.
// ---------------------------------------------------------------------------
//
CBTNotifServer* CBTNotifServer::NewLC()
    {
    CBTNotifServer* self = new( ELeave ) CBTNotifServer();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CBTNotifServer::~CBTNotifServer()
    {
    delete iDevSelector;
    delete iSettingsTracker;
    delete iConnectionTracker;
    delete iNotificationMgr;
    delete iAsyncCb;
    delete iTimer;
    delete iDevRep;
    }

// ---------------------------------------------------------------------------
// Handle a change in BT power state.
// ---------------------------------------------------------------------------
//
void CBTNotifServer::HandlePowerStateChangeL( TBTPowerStateValue aState )
    {
    if( aState && !iConnectionTracker )
        {
        // only construct tracker if it is not available yet
        iConnectionTracker = CBTNotifConnectionTracker::NewL( this );
        }
    else
        {
        delete iConnectionTracker;
        iConnectionTracker = NULL;
        }
    CheckIdle( aState );
    }

// ---------------------------------------------------------------------------
// Increase the session count.
// ---------------------------------------------------------------------------
//
void CBTNotifServer::AddSession()
    {
    ++iSessionCount;
    iTimer->Remove( iShutdownTimerEntry );
    }


// ---------------------------------------------------------------------------
// Decrease the session count.
// ---------------------------------------------------------------------------
//
void CBTNotifServer::RemoveSession()
    {
    if ( iSessionCount > 0 )
        {
        // session counter can't be less than 0
        --iSessionCount;
        }
    CheckIdle( iSettingsTracker->GetPowerState() );
    }

// ---------------------------------------------------------------------------
// get the singleton instance of device repository
// ---------------------------------------------------------------------------
//
CBtDevRepository& CBTNotifServer::DevRepository()
    {
    return *iDevRep;
    }

// ---------------------------------------------------------------------------
// get the singleton instance of device search notifier
// ---------------------------------------------------------------------------
//
CBTNotifDeviceSelector& CBTNotifServer::DeviceSelectorL()
    {
    if ( ! iDevSelector )
        {
        iDevSelector = CBTNotifDeviceSelector::NewL( *this );
        }
    return *iDevSelector;
    }

// ---------------------------------------------------------------------------
// Searches for a client message from a message handle and completes it.
// ---------------------------------------------------------------------------
//
TInt CBTNotifServer::CompleteMessage( TInt aHandle, TInt aReason, const TDesC8& aReply )
    {
    TInt err = KErrNotFound;
    iSessionIter.SetToFirst();
    CBTNotifSession* session = NULL;
    while( ( session = (CBTNotifSession*) iSessionIter++ ) != NULL )
        {
        err = session->CompleteMessage( aHandle, aReason, aReply );
        if( err != KErrNotFound )
            {
            // Found the correct session, and message, and completed it.
            break;
            }
        }
    return err;
    }


// ---------------------------------------------------------------------------
// Searches for a client message from a message handle and returns it.
// ---------------------------------------------------------------------------
//
const RMessage2* CBTNotifServer::FindMessageFromHandle( TInt aHandle )
    {
    const RMessage2* message = NULL;
    iSessionIter.SetToFirst();
    CBTNotifSession* session = NULL;
    while( ( session = (CBTNotifSession*) iSessionIter++ ) != NULL )
        {
        message = session->FindMessageFromHandle( aHandle );
        if( message )
            {
            // Found the correct session and message to return.
            break;
            }
        }
    return message;
    }


// ---------------------------------------------------------------------------
// Searches for a client message from a message handle and returns it.
// ---------------------------------------------------------------------------
//
const RMessage2* CBTNotifServer::FindMessageFromUid( TInt aUid )
    {
    const RMessage2* message = NULL;
    iSessionIter.SetToFirst();
    CBTNotifSession* session = NULL;
    while( ( session = (CBTNotifSession*) iSessionIter++ ) != NULL )
        {
        message = session->FindMessageFromUid( aUid );
        if( message )
            {
            // Found the correct session and message to return.
            break;
            }
        }
    return message;
    }


// ---------------------------------------------------------------------------
// From class CPolicyServer.
// Create a new session object.
// ---------------------------------------------------------------------------
//
CSession2* CBTNotifServer::NewSessionL( const TVersion& aVersion, 
    const RMessage2& aMessage ) const
    {
    (void) aMessage;
    // Compare our version with client-side version, CServer2 requires that 
    // we leave if they are not compatible. 
    TVersion srvVersion( KBTNotifServerVersionMajor, KBTNotifServerVersionMinor, 
                          KBTNotifServerVersionBuild );

    if( !User::QueryVersionSupported( aVersion, srvVersion ) )
        {
        // EFalse is returned if our version is not less than or 
        // equal to the client version.
        User::Leave( KErrNotSupported );
        }
    return CBTNotifSession::NewL();
    }

void CBTNotifServer::CheckIdle( TBTPowerStateValue aState )
    {
    // In special scenarios, we do not have to remove the timer and queue it 
    // again, but these scenarios rarely happen in end-user use cases. 
    iTimer->Remove( iShutdownTimerEntry );
    if ( iSessionCount == 0 && aState == EBTPowerOff )
        {
        // BT power is off, start the shutdown timer.
        TTimeIntervalMicroSeconds32 interval = KBTNtoifShutdownTimeout;
        iTimer->Queue( interval, iShutdownTimerEntry );
        }
    }

TInt CBTNotifServer::ShutdownTimeout( TAny* aPtr )
    {
    (void) aPtr;
    CActiveScheduler::Stop();
    return KErrNone;    
    }

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

// ---------------------------------------------------------------------------
// Main function of the executable.
// ---------------------------------------------------------------------------
//
GLDEF_C TInt E32Main()
    {
    __UHEAP_MARK;
    CTrapCleanup* cleanup = CTrapCleanup::New();
    TInt err = KErrNoMemory;
    if ( cleanup )
        {
        TRAP( err, RunServerL() );
        delete cleanup;
        }
    __UHEAP_MARKEND;
    return err;
    }