/*

* Copyright (c) 2006-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-side implementation of BTEng

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <bthci.h>

#include <bt_subscribe_partner.h>

#endif

#include <e32base.h>

#include <btmanclient.h>

#include <es_sock.h>

#include <btnotif.h>

#include <utf.h>

#include <ecom/ecom.h>

#include <centralrepository.h>

#include <featmgr.h>

#include <AknSmallIndicator.h>

#include <avkon.hrh>

#include <bt_subscribe.h>

#include "btengserver.h"

#include "btengsrvstate.h"

#include "btengsrvsession.h"

#include "btengsrvpluginmgr.h"

#include "btengsrvbbconnectionmgr.h"

#include "btengsrvkeywatcher.h"

#include "btengsdpdbhandler.h"

#include "btengclientserver.h"

#include "btengsecpolicy.h"

#include "btengprivatecrkeys.h"

#include "btengprivatepskeys.h"

#include "btengplugin.h"

#include "btengpairman.h"

#include "debug.h"

/**  Bluetooth Engine server thread name */

_LIT( KBTEngThreadName, "BTEngine" );

/**  Constant for converting minutes to microseconds */

const TInt64 KMinutesInMicroSecs = MAKE_TINT64( 0, 60000000 );

/**  Idle timeout for shutting down the server (when power is off, 

 *   and no clients are connected). The value is 3 seconds.

 */

const TInt KBTEngSrvIdleTimeout = 3000000;

/**  Timeout for disabling Simple Pairing debug mode. The value is 30 minutes. */

const TInt KBTEngSspDebugModeTimeout = 1800000000;

/**  Timeout for determining that BT is not turned off automatically. 

 *   The value is 10.5 seconds.

 */

const TInt KBTEngBtAutoOffTimeout = 10500000;

/**  Enumeration of bitmask for keeping track of different timers. */

enum TTimerQueued

    {

    ENone               = 0x00,

    EScanModeTimer      = 0x01,

    EIdleTimer          = 0x02,

    EAutoPowerOffTimer  = 0x04,

    ESspDebugModeTimer  = 0x08 

    };

/**  PubSub key read and write policies */

_LIT_SECURITY_POLICY_C2( KBTEngPSKeyReadPolicy, 

                          ECapabilityLocalServices, ECapabilityReadDeviceData );

_LIT_SECURITY_POLICY_C2( KBTEngPSKeyWritePolicy, 

                          ECapabilityLocalServices, ECapabilityWriteDeviceData );

// Default values for Major and Minor Device Class

const TUint16 KCoDDefaultServiceClass = EMajorServiceTelephony | EMajorServiceObjectTransfer | EMajorServiceNetworking;

const TUint8 KCoDDefaultMajorDeviceClass = EMajorDevicePhone;

const TUint8 KCoDDefaultMinorDeviceClass = EMinorDevicePhoneSmartPhone;

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

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

// Constructs and returns an application object.

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

//

void RunServerL()

    {

    TRACE_FUNC_ENTRY

    User::RenameThread( KBTEngThreadName );

        // Create and install the active scheduler for this thread.

    CActiveScheduler* scheduler = new( ELeave ) CActiveScheduler();

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

        // create the server (leave it on the cleanup stack)

	CBTEngServer* btServer = CBTEngServer::NewLC();

        // Initialisation complete, now signal the client

    RProcess::Rendezvous( KErrNone );

        // The server is not up and running.

    TRACE_INFO( ( _L( "[BTENG]\t BTEng server now up and running" ) ) )

	    // The active scheduler runs during the lifetime of this thread.

    CActiveScheduler::Start();

        // Cleanup the server and scheduler.

    CleanupStack::PopAndDestroy( btServer );

    CleanupStack::PopAndDestroy( scheduler );

    TRACE_FUNC_EXIT

    }

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

// Completes the message and panics the client.

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

//

void PanicClient( const RMessage2& aMessage, TInt aPanic )

    {

    TRACE_INFO( ( _L( "[BTENG]\t PanicClient: Reason %d" ), aPanic ) )

    aMessage.Panic( KBTEngPanic, aPanic );

    }

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

// Panic the server.

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

//

void PanicServer( TInt aPanic )

    {

    TRACE_INFO( ( _L( "[BTENG]\t PanicClient: Reason %d" ), aPanic ) )

    User::Panic( KBTEngPanic, aPanic );

    }

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

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

// C++ default constructor

// (Priority is not as high as in prev. architecture, but should be enough)

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

//

CBTEngServer::CBTEngServer()

:   CPolicyServer( EPriorityHigh, KBTEngServerPolicy )

    {

    iEnableDutMode = EFalse;

    }

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

// Symbian 2nd-phase constructor

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

//

void CBTEngServer::ConstructL()

    {

    TRACE_FUNC_ENTRY

        // No need to check _BT flag here, as the server can 

        // only be started by BTEng components.

        // Add the server to the active scheduler (from CServer2):

    StartL( KBTEngServerName );

    User::LeaveIfError( RProperty::Define( KPSUidBluetoothTestingMode, KBTDutEnabled, 

                                            RProperty::EInt, KBTEngPSKeyReadPolicy, 

                                            KBTEngPSKeyWritePolicy ) );

    User::LeaveIfError( RProperty::Define( KPSUidBluetoothTestingMode, KBTSspDebugmode, 

                                            RProperty::EInt, KBTEngPSKeyReadPolicy, 

                                            KBTEngPSKeyWritePolicy ) );

    User::LeaveIfError( RProperty::Define( KPSUidBluetoothEnginePrivateCategory, 

                                            KBTBlockDevAddr, RProperty::EText, 

                                            KBTEngPSKeyReadPolicy, 

                                            KBTEngPSKeyWritePolicy ) );

    User::LeaveIfError( RProperty::Define( KPSUidBluetoothEnginePrivateCategory,

                                            KBTOutgoingPairing,

                                            RProperty::EByteArray,

                                            KBTEngPSKeyReadPolicy,

                                            KBTEngPSKeyWritePolicy) );

    User::LeaveIfError( RProperty::Define( KPSUidBluetoothEnginePrivateCategory,

                                            KBTConnectionTimeStamp,

                                            RProperty::EByteArray,

                                            KBTEngPSKeyReadPolicy,

                                            KBTEngPSKeyWritePolicy) );

    User::LeaveIfError( RProperty::Define( KPSUidBluetoothEnginePrivateCategory,

                                            KBTTurnBTOffQueryOn,

                                            RProperty::EInt,

                                            KBTEngPSKeyReadPolicy,

                                            KBTEngPSKeyWritePolicy) );

    User::LeaveIfError( RProperty::Define( KPSUidBluetoothEnginePrivateCategory,

                                            KBTNotifierLocks,

                                            RProperty::EByteArray,

                                            KBTEngPSKeyReadPolicy,

                                            KBTEngPSKeyWritePolicy) );    

    User::LeaveIfError( iSocketServ.Connect() );

    LoadBTPowerManagerL();

        // The server is only started by its client, so leave the state 

        // machine in Init state. A request to turn power on will follow 

        // usually immediately.

    iServerState = CBTEngSrvState::NewL( this );

    iWatcher = CBTEngSrvKeyWatcher::NewL( this );

    iPluginMgr = CBTEngSrvPluginMgr::NewL( this );

    iBBConnMgr = CBTEngSrvBBConnMgr::NewL( iSocketServ );

    User::LeaveIfError( iBTRegServ.Connect() );

    iPairMan = CBTEngPairMan::NewL( *this );

    TCallBack idleCb( IdleTimerCallBack, this );

    iIdleCallBack.Set( idleCb );

    TCallBack sspCb( DebugModeTimerCallBack, this );

    iDebugModeCallBack.Set( sspCb );

    TCallBack scanModeCb( ScanModeTimerCallBack, this );

    iScanModeCallBack.Set( scanModeCb );

    TCallBack powerOffCb( AutoPowerOffCallBack, this );

    iPowerOffCallBack.Set( powerOffCb );

    iTimer = CDeltaTimer::NewL(CActive::EPriorityLow);

    iEnterpriseEnablementMode = BluetoothFeatures::EnterpriseEnablementL();

	TRACE_INFO( ( _L( "iEnterpriseEnablementMode = %d" ), iEnterpriseEnablementMode) )

    if ( iEnterpriseEnablementMode == BluetoothFeatures::EDisabled )

        {

        SetVisibilityModeL( EBTVisibilityModeNoScans, 0 );

        }

    TRACE_FUNC_EXIT

    }

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

// NewL

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

//

CBTEngServer* CBTEngServer::NewLC()

    {

    CBTEngServer* self = new( ELeave ) CBTEngServer();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CBTEngServer::~CBTEngServer()

    {

    TRACE_FUNC_ENTRY

    if( iTimer )

        {

        iTimerQueued = ENone;

        iTimer->Remove( iScanModeCallBack );

        iTimer->Remove( iPowerOffCallBack );

        iTimer->Remove( iIdleCallBack);

        iTimer->Remove( iDebugModeCallBack );

        }

    RProperty::Delete( KPSUidBluetoothTestingMode, KBTDutEnabled );

    RProperty::Delete( KPSUidBluetoothTestingMode, KBTSspDebugmode );

    RProperty::Delete( KPSUidBluetoothEnginePrivateCategory, KBTBlockDevAddr );

    RProperty::Delete( KPSUidBluetoothEnginePrivateCategory, KBTOutgoingPairing );

    RProperty::Delete( KPSUidBluetoothEnginePrivateCategory, KBTConnectionTimeStamp );

    RProperty::Delete( KPSUidBluetoothEnginePrivateCategory, KBTTurnBTOffQueryOn );

    RProperty::Delete( KPSUidBluetoothEnginePrivateCategory, KBTNotifierLocks );

    delete iTimer;

    delete iSdpDbHandler;

    delete iWatcher;

    delete iPluginMgr;

    delete iBBConnMgr;

    delete iServerState;

    delete iPairMan;

    iPowerMgr.Close();

    iSocketServ.Close();

    iBTRegServ.Close();

    }

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

// Turn BT on or off.

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

//

void CBTEngServer::SetPowerStateL( TBTPowerStateValue aState, TBool aTemporary )

    {

    TRACE_FUNC_ARG( ( _L( "setting power state %d" ), (TInt) aState ) )

    if ( aState == EBTPowerOn && iEnterpriseEnablementMode == BluetoothFeatures::EDisabled )

        {

        TRACE_INFO( ( _L( "\tno we're not... Bluetooth is enterprise-IT-disabled" ) ) )

        User::Leave(KErrNotSupported);

        }

    TBTPowerStateValue currentState = EBTPowerOff;

    CheckTemporaryPowerStateL( currentState, aState, aTemporary );

    if( ( currentState == aState || ( aTemporary && aState == EBTPowerOff ) ) && iServerState->CurrentOperation() == CBTEngSrvState::ESrvOpIdle )

        {

		// The requested power state is already active, ignore silently.

		// We don't return an error here, as there is no error situation.

        TRACE_INFO( ( _L( "SetPowerStateL: nothing to do" ) ) )

        if(currentState == aState)

            {

            // Make sure that the CenRep key is in sync.

            // During boot-up, the pwoer is set from the CenRep key, so we could 

            // end up out-of-sync.

            TRACE_INFO( ( _L( "SetPowerStateL: currentState == aState" ) ) )

            UpdateCenRepPowerKeyL( aState );

            } 

        return;

        }

    if( aState )

        {

            // Hardware power on is the first step.

        User::LeaveIfError( SetPowerState( aState ) );

        }

    else

        {

        //Prevent BT visibility in the situation when we turn OFF BT Engine 

        //but FM Radio is still alive

        SetVisibilityModeL( EBTVisibilityModeNoScans, 0 );

            // Hardware power off is the last step.

            // First disconnect all plug-ins.

        iPluginMgr->DisconnectAllPlugins();

        }

        // We only signal that BT is on after everything has completed (through 

        // the CenRep power state key), so that all services are initialized.

        // We signal that BT is off immediately though, so that our clients will 

        // not try to use BT during power down.

    iServerState->StartStateMachineL( (TBool) aState );

    TRACE_FUNC_EXIT

    }

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

// ?implementation_description

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

//

void CBTEngServer::SetVisibilityModeL( TBTVisibilityMode aMode, TInt aTime )

    {

    TRACE_FUNC_ENTRY

    if ( aMode != EBTVisibilityModeNoScans && iEnterpriseEnablementMode == BluetoothFeatures::EDisabled )

        {

        TRACE_INFO( ( _L( "\tnot changing anything... Bluetooth is enterprise-IT-disabled" ) ) )

        User::Leave(KErrNotSupported);

        }

    TInt err = KErrNone;

    iTimerQueued &= ~EScanModeTimer;

    iTimer->Remove( iScanModeCallBack );

    if( aMode != EBTVisibilityModeNoScans )

        {

        CRepository* cenRep = CRepository::NewL( KCRUidBTEngPrivateSettings );

        err = cenRep->Set( KBTDiscoverable, aMode );

        delete cenRep;

        }

    if( !err && aMode == EBTVisibilityModeTemporary )

        {

            // We need TInt64 here, as the max. time in microseconds for the 

            // max. value (1 hour) is larger than KMaxTInt32.

        TInt64 timeMicroSec = MAKE_TINT64( 0, aTime );

        timeMicroSec = timeMicroSec * KMinutesInMicroSecs;

        TTimeIntervalMicroSeconds interval( timeMicroSec );

            // Queue callback to set the visibility back to hidden.

        err = iTimer->QueueLong( interval, iScanModeCallBack );

        iTimerQueued |= EScanModeTimer;

        aMode = EBTVisibilityModeGeneral;

		}

    else if( !err && iRestoreVisibility )

        {

            // The user overrides, do not restore visibility mode anymore.

        iRestoreVisibility = EFalse;

        }

    if( !err )

        {

        err = RProperty::Set( KUidSystemCategory, 

                               KPropertyKeyBluetoothSetScanningStatus, aMode );

        }

    TBool hiddenMode = ( aMode == EBTVisibilityModeHidden );

    if( !err && aMode != EBTVisibilityModeNoScans )

        {

            // In hidden mode, we only accept connections from paired devices.

        err = RProperty::Set( KUidSystemCategory, 

                               KPropertyKeyBluetoothSetAcceptPairedOnlyMode, 

                               hiddenMode );

        }

    User::LeaveIfError( err );  // To communicate the result to the client.

    TRACE_FUNC_EXIT

    }

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

// The method is called when BT stack scanning mode P&S key is changed

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

//

void CBTEngServer::UpdateVisibilityModeL( TInt aStackScanMode )

    {

    TRACE_FUNC_ENTRY

    TRACE_INFO( ( _L( "[BTEng]\t aStackScanMode: %d" ), aStackScanMode ) )

    TBTVisibilityMode currentMode;

    CRepository* cenRep = CRepository::NewLC( KCRUidBTEngPrivateSettings );

    User::LeaveIfError( cenRep->Get( KBTDiscoverable, (TInt&) currentMode ) );

        // In case we are in temp visibility mode, we cannot always know whether the BT stack

        // scan mode key was set by some external party or by us in SetVisibilityModeL above.

        // Therefore we cannot stop the timer in case aMode is EBTVisibilityModeGeneral and 

        // currentmode is EBTVisibilityModeTemporary

    if( !( currentMode == EBTVisibilityModeTemporary && aStackScanMode == EBTVisibilityModeGeneral ) )

        {

            // Cancel the timer and queue it again if needed.

        iTimerQueued &= ~EScanModeTimer;

        iTimer->Remove( iScanModeCallBack );

        if( currentMode != aStackScanMode )

            {

            if( aStackScanMode == EPageScanOnly || aStackScanMode == EInquiryAndPageScan )

                {

                User::LeaveIfError( cenRep->Set( KBTDiscoverable, aStackScanMode ) );

                }

            else if( aStackScanMode == EInquiryScanOnly )

                {

                    // We don't support ENoScansEnabled nor EInquiryScanOnly mode

                    // -> Consider these as same as Hidden 

                User::LeaveIfError( cenRep->Set( KBTDiscoverable, EBTVisibilityModeHidden ) );

                }

            else if( aStackScanMode == ENoScansEnabled )

                {

                //We don't change KBTDiscoverable here, because ENoScansEnabled

                //indicates BT/SYSTEM shutdown is happening

                }

            }

        }

    SetUiIndicatorsL();

    CleanupStack::PopAndDestroy( cenRep );

    TRACE_FUNC_EXIT

    }

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

// ?implementation_description

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

//

void CBTEngServer::DisconnectAllL()

    {

    TRACE_FUNC_ENTRY

    iPluginMgr->DisconnectAllPlugins();

    TCallBack cb( DisconnectAllCallBack, this );

    iBBConnMgr->DisconnectAllLinksL( cb );

    }

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

// ?implementation_description

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

//

void CBTEngServer::SetDutMode( TInt aDutMode )

    {

    TRACE_FUNC_ARG( ( _L( "DUT mode %d" ), aDutMode ) )

    if (aDutMode == EBTDutOff)

        {

        return;

        }

    TInt powerState = EBTPowerOff;

    CRepository* cenrep = NULL;

    TRAPD(err, cenrep = CRepository::NewL(KCRUidBluetoothPowerState));

    if (!err && cenrep)

        {

        cenrep->Get(KBTPowerState, powerState);

        delete cenrep;

        cenrep = NULL;

        }

    else

        {

        return;

        }

    if (powerState == EBTPowerOn)

        {

#ifndef __WINS__

        TInt err = iDutMode.Open();

        TRACE_FUNC_ARG( ( _L( "Open DUT mode handle err %d" ), err) )

        if(!err) 

            {

            iDutMode.ActivateDutMode();

            iDutMode.Close();

            }

#endif  //__WINS__                        

        }

        iEnableDutMode = EFalse;    

    }

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

// ?implementation_description

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

//

void CBTEngServer::ScanModeTimerCompletedL()

    {

    TRACE_FUNC_ENTRY

    // The timer has completed, so remove our reference as well.

    iTimerQueued &= ~EScanModeTimer;

    iTimer->Remove( iScanModeCallBack );

    SetVisibilityModeL( EBTVisibilityModeHidden, 0 );

    TBTPowerStateValue power = EBTPowerOff;

    TInt err = GetHwPowerState( (TBTPowerStateValue&) power );

    if( !err && power )

        {

        // Show a notification to the user

        TBTGenericInfoNotiferParamsPckg pckg;

        pckg().iMessageType = EBTVisibilityTimeout;

        RNotifier notifier;

        TInt err = notifier.Connect();

        if( !err )

            {

            err = notifier.StartNotifier( KBTGenericInfoNotifierUid, pckg );

            notifier.Close();

            }

        }

    TRACE_FUNC_RES( ( _L( "result: %d" ), err ) )

    }