bluetoothengine/bteng/src/btengsrvsettingsmgr.cpp
branchRCL_3
changeset 10 0707dd69d236
child 11 a42ed326b458
equal deleted inserted replaced
6:6a29d5ad0713 10:0707dd69d236
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: Class to manage Bluetooth hardware and stack settings.
       
    15 *
       
    16 */
       
    17 
       
    18 #include "btengsrvsettingsmgr.h"
       
    19 #include <bthci.h>
       
    20 #include <bt_subscribe_partner.h>
       
    21 #include <btnotif.h>
       
    22 #include <btengdomainpskeys.h>
       
    23 #include <centralrepository.h>
       
    24 #include <featmgr.h>
       
    25 #include <AknSmallIndicator.h>
       
    26 #include <avkon.hrh>
       
    27 
       
    28 #include "btengserver.h"
       
    29 #include "btengsrvpluginmgr.h"
       
    30 #include "btengsrvbbconnectionmgr.h"
       
    31 #include "btengsrvstate.h"
       
    32 #include "debug.h"
       
    33 
       
    34 #ifndef SETLOCALNAME
       
    35 #include <btengsettings.h>
       
    36 #endif
       
    37 
       
    38 /** ID of active object helper */
       
    39 const TInt KBTEngSettingsActive = 30;
       
    40 /** Constant for converting minutes to microseconds */
       
    41 //const TInt64 KMinutesInMicroSecs = 60000000;
       
    42 const TInt64 KMinutesInMicroSecs = MAKE_TINT64( 0, 60000000 );
       
    43 /**  Timeout for disabling Simple Pairing debug mode. The value is 30 minutes. */
       
    44 //const TInt KBTEngSspDebugModeTimeout = 1800000000;
       
    45 const TInt64 KBTEngSspDebugModeTimeout = MAKE_TINT64( 0, 1800000000 );
       
    46 /**  Timeout for turning BT off automatically. The value is 10.5 seconds. */
       
    47 const TInt KBTEngBtAutoOffTimeout = 10500000;
       
    48 /**  Default values for Major Service Class */
       
    49 const TUint16 KCoDDefaultServiceClass = EMajorServiceTelephony | EMajorServiceObjectTransfer | EMajorServiceNetworking;
       
    50 /**  Default values for Major Device Class */
       
    51 const TUint8 KCoDDefaultMajorDeviceClass = EMajorDevicePhone;
       
    52 /**  Default values for Minor Device Class */
       
    53 const TUint8 KCoDDefaultMinorDeviceClass = EMinorDevicePhoneSmartPhone;
       
    54 
       
    55 
       
    56 // ======== MEMBER FUNCTIONS ========
       
    57 
       
    58 // ---------------------------------------------------------------------------
       
    59 // C++ default constructor
       
    60 // ---------------------------------------------------------------------------
       
    61 //
       
    62 CBTEngSrvSettingsMgr::CBTEngSrvSettingsMgr( CBTEngServer* aServer )
       
    63 :   iServer( aServer )
       
    64     {
       
    65     }
       
    66 
       
    67 
       
    68 // ---------------------------------------------------------------------------
       
    69 // Symbian second-phase constructor
       
    70 // ---------------------------------------------------------------------------
       
    71 //
       
    72 void CBTEngSrvSettingsMgr::ConstructL()
       
    73     {
       
    74     TRACE_FUNC_ENTRY
       
    75     iActive = CBTEngActive::NewL( *this, KBTEngSettingsActive );
       
    76     LoadBTPowerManagerL();
       
    77     iEnterpriseEnablementMode = BluetoothFeatures::EnterpriseEnablementL();
       
    78     TRACE_INFO( ( _L( "iEnterpriseEnablementMode = %d" ), iEnterpriseEnablementMode) )
       
    79     if ( iEnterpriseEnablementMode == BluetoothFeatures::EDisabled )
       
    80         {
       
    81         SetVisibilityModeL( EBTVisibilityModeNoScans, 0 );
       
    82         }
       
    83     TRACE_FUNC_EXIT
       
    84     }
       
    85 
       
    86 
       
    87 // ---------------------------------------------------------------------------
       
    88 // NewL
       
    89 // ---------------------------------------------------------------------------
       
    90 //
       
    91 CBTEngSrvSettingsMgr* CBTEngSrvSettingsMgr::NewL( CBTEngServer* aServer )
       
    92     {
       
    93     CBTEngSrvSettingsMgr* self = new( ELeave ) CBTEngSrvSettingsMgr( aServer );
       
    94     CleanupStack::PushL( self );
       
    95     self->ConstructL();
       
    96     CleanupStack::Pop( self );
       
    97     return self;
       
    98     }
       
    99 
       
   100 
       
   101 // ---------------------------------------------------------------------------
       
   102 // Destructor
       
   103 // ---------------------------------------------------------------------------
       
   104 //
       
   105 CBTEngSrvSettingsMgr::~CBTEngSrvSettingsMgr()
       
   106     {
       
   107     if( iActive && iActive->IsActive() )
       
   108         {
       
   109         // Cancel the outstanding request.
       
   110         iPowerMgr.Cancel();
       
   111         }
       
   112     delete iActive;  
       
   113     iPowerMgr.Close();
       
   114     }
       
   115 
       
   116 
       
   117 // ---------------------------------------------------------------------------
       
   118 // Power Bluetooth hardware on or off.
       
   119 // ---------------------------------------------------------------------------
       
   120 //
       
   121 TInt CBTEngSrvSettingsMgr::SetHwPowerState( TBTPowerState aState )
       
   122     {
       
   123     TRACE_FUNC_ENTRY
       
   124     TInt err = KErrNone;
       
   125 #ifndef __WINS__
       
   126     if( iActive->IsActive() )
       
   127         {
       
   128         // Cancel the outstanding request.
       
   129         iPowerMgr.Cancel();
       
   130         iActive->Cancel();
       
   131         }
       
   132     iPowerMgr.SetPower( aState, NULL, iActive->RequestStatus() );
       
   133     iActive->GoActive();
       
   134 #else   //__WINS__
       
   135     iPowerState = aState;
       
   136 #endif  //__WINS__
       
   137 
       
   138    if( !err && aState == EBTOn )
       
   139         {
       
   140         TInt dutMode = EBTDutOff;
       
   141         err = RProperty::Get( KPSUidBluetoothTestingMode, KBTDutEnabled, dutMode );
       
   142         if( !err && dutMode == EBTDutOn )
       
   143             {
       
   144             // Set the DUT mode key to OFF since DUT mode is disabled at this point
       
   145             err = RProperty::Set( KPSUidBluetoothTestingMode, KBTDutEnabled, EBTDutOff );
       
   146             }
       
   147         }
       
   148     if( err )
       
   149         {
       
   150         // Power off if an error occurred during power on sequence.
       
   151 #ifndef __WINS__
       
   152             // This cannot happen in emulator environment.
       
   153         iPowerMgr.Cancel();
       
   154         iActive->Cancel();
       
   155         iPowerMgr.SetPower( EBTOff, NULL, iActive->RequestStatus() );
       
   156         User::WaitForRequest( iActive->RequestStatus() );
       
   157         // Result will be communicated through the caller of this function (by leaving).
       
   158 #else   //__WINS__
       
   159         iPowerState = EBTOff;
       
   160 #endif  //__WINS__
       
   161         } 
       
   162     TRACE_FUNC_RES( ( _L( "result: %d" ), err ) )
       
   163     return err;
       
   164     }
       
   165 
       
   166 
       
   167 // ---------------------------------------------------------------------------
       
   168 // Turn BT on or off.
       
   169 // ---------------------------------------------------------------------------
       
   170 //
       
   171 void CBTEngSrvSettingsMgr::SetPowerStateL( TBTPowerState aState, TBool aTemporary )
       
   172     {
       
   173     TRACE_FUNC_ARG( ( _L( "%d (temporary=%d" ), aState, aTemporary ) )
       
   174     if ( aState == EBTOn && iEnterpriseEnablementMode == BluetoothFeatures::EDisabled )
       
   175         {
       
   176         TRACE_INFO( ( _L( "no we're not... Bluetooth is enterprise-IT-disabled" ) ) )
       
   177         User::Leave(KErrNotSupported);
       
   178         }
       
   179     TBool idle = ( iServer->StateMachine()->CurrentOperation() == CBTEngSrvState::ESrvOpIdle );
       
   180     TBTPowerState currentState = EBTOff;
       
   181     CheckTemporaryPowerStateL( currentState, aState, aTemporary );
       
   182 
       
   183     if ( ( currentState == aState || ( aTemporary && aState == EBTOff ) ) && idle )
       
   184         {
       
   185         // The requested power state is already active, ignore silently.
       
   186         // We don't return an error here, as there is no error situation.
       
   187         TRACE_INFO( ( _L( "SetPowerStateL: nothing to do" ) ) )
       
   188         if ( currentState == aState )
       
   189             {
       
   190             // Make sure that the CenRep key is in sync.
       
   191             // During boot-up, the pwoer is set from the CenRep key, so we could 
       
   192             // end up out-of-sync.
       
   193             TRACE_INFO( ( _L( "SetPowerStateL: currentState == aState" ) ) )
       
   194             UpdateCenRepPowerKeyL( aState );
       
   195             } 
       
   196         return;
       
   197         }
       
   198     if ( aState == EBTOn )
       
   199         {
       
   200         // Hardware power on is the first step.
       
   201         User::LeaveIfError( SetHwPowerState( aState ) );
       
   202         }
       
   203     else
       
   204         {
       
   205         //Prevent BT visibility in the situation when we turn OFF BT Engine 
       
   206         //but FM Radio is still alive
       
   207         SetVisibilityModeL( EBTVisibilityModeNoScans, 0 );
       
   208         // Hardware power off is the last step.
       
   209         // First disconnect all plug-ins.
       
   210         iServer->PluginManager()->DisconnectAllPlugins();
       
   211         }
       
   212     // We only signal that BT is on after everything has completed (through 
       
   213     // the CenRep power state key), so that all services are initialized.
       
   214     // We signal that BT is off immediately though, so that our clients will 
       
   215     // not try to use BT during power down.
       
   216     iServer->StateMachine()->StartStateMachineL( aState );
       
   217     TRACE_FUNC_EXIT
       
   218     }
       
   219 
       
   220 // ---------------------------------------------------------------------------
       
   221 // Turn BT on or off.
       
   222 // ---------------------------------------------------------------------------
       
   223 //
       
   224 void CBTEngSrvSettingsMgr::SetPowerStateL(const RMessage2 aMessage )
       
   225     {
       
   226     TRACE_FUNC_ENTRY
       
   227     __ASSERT_ALWAYS( aMessage.Function() == EBTEngSetPowerState, 
       
   228             PanicServer( EBTEngPanicExpectSetPowerOpcode ) );
       
   229     if ( !iMessage.IsNull() )
       
   230         {
       
   231         // A power management request from a client is outstanding.
       
   232         User::Leave( KErrAlreadyExists );
       
   233         }
       
   234  
       
   235     TBTPowerStateValue arg = (TBTPowerStateValue) aMessage.Int0();
       
   236     // TBTPowerState power state type is inverted from TBTPowerStateValue,
       
   237     // which is used by the client to pass the parameter...
       
   238     TBTPowerState reqedPowerState( EBTOff );
       
   239     if ( arg == EBTPowerOn )
       
   240         {
       
   241         reqedPowerState = EBTOn;
       
   242         }
       
   243     TBool tempPowerOn = (TBool) aMessage.Int1();
       
   244     
       
   245     SetPowerStateL( reqedPowerState, tempPowerOn );
       
   246     if ( iServer->StateMachine()->CurrentOperation() == CBTEngSrvState::ESrvOpIdle )
       
   247         {
       
   248         // The request is accepted but the state machine is not running. This means the
       
   249         // requested power state is already active. Request is done.
       
   250         aMessage.Complete( KErrNone );
       
   251         }
       
   252     else
       
   253         {
       
   254         iMessage = RMessage2( aMessage );
       
   255         }
       
   256     TRACE_FUNC_EXIT
       
   257     }
       
   258 
       
   259 // ---------------------------------------------------------------------------
       
   260 // Initialize Bluetooth stack settings.
       
   261 // ---------------------------------------------------------------------------
       
   262 //
       
   263 void CBTEngSrvSettingsMgr::InitBTStackL()
       
   264     {
       
   265     TRACE_FUNC_ENTRY
       
   266     iServer->BasebandConnectionManager()->Subscribe();
       
   267     TBTVisibilityMode visibility = EBTVisibilityModeHidden;
       
   268     CRepository* cenRep = CRepository::NewL( KCRUidBTEngPrivateSettings );
       
   269     TInt err = cenRep->Get( KBTDiscoverable, (TInt&) visibility );
       
   270     delete cenRep;
       
   271     if (iRestoreVisibility == EFalse)
       
   272         {
       
   273         if( err || visibility == EBTVisibilityModeTemporary &&
       
   274             !( iServer->IsTimerQueued( CBTEngServer::EScanModeTimer ) ) )
       
   275             {
       
   276             visibility = EBTVisibilityModeHidden;
       
   277             }
       
   278         SetVisibilityModeL( visibility, 0 );
       
   279         }
       
   280 
       
   281     TBool sspDebugMode = EFalse;
       
   282     (void) RProperty::Get( KPropertyUidBluetoothCategory,
       
   283                 KPropertyKeyBluetoothGetSimplePairingDebugMode, (TInt&) sspDebugMode );
       
   284         // Only set debug mode to off if it is on, to prevent a loop notifications.
       
   285     if( sspDebugMode )
       
   286         {
       
   287         sspDebugMode = EFalse;
       
   288         // Add LeaveIfError if unsuccessful
       
   289         (void) RProperty::Set(KPropertyUidBluetoothCategory,
       
   290                     KPropertyKeyBluetoothSetSimplePairingDebugMode, (TInt) sspDebugMode );
       
   291         }
       
   292     TRACE_FUNC_EXIT
       
   293     }
       
   294 
       
   295 
       
   296 // ---------------------------------------------------------------------------
       
   297 // Reset settings and disconnect all links.
       
   298 // ---------------------------------------------------------------------------
       
   299 //
       
   300 void CBTEngSrvSettingsMgr::StopBTStackL()
       
   301     {
       
   302     TRACE_FUNC_ENTRY
       
   303     TBTVisibilityMode visibility = EBTVisibilityModeHidden;
       
   304     CRepository* cenRep = CRepository::NewL( KCRUidBTEngPrivateSettings );
       
   305           // Ignore error here; if we can't read it, likely we can't set it either.
       
   306     (void) cenRep->Get( KBTDiscoverable, (TInt&) visibility );
       
   307     delete cenRep;
       
   308     if( visibility == EBTVisibilityModeTemporary )
       
   309         {
       
   310         visibility = EBTVisibilityModeHidden;
       
   311         SetVisibilityModeL( visibility, 0 );    // Also cancels scan mode timer.
       
   312         }
       
   313 
       
   314         // Stop listening to events
       
   315     iServer->BasebandConnectionManager()->Unsubscribe();
       
   316         // Disconnect all links
       
   317     TCallBack cb( CBTEngServer::DisconnectAllCallBack, iServer );
       
   318     iServer->BasebandConnectionManager()->DisconnectAllLinksL( cb );
       
   319         // Results in a callback (which is called directly when there are no links).
       
   320     TRACE_FUNC_EXIT
       
   321     }
       
   322 
       
   323 
       
   324 // ---------------------------------------------------------------------------
       
   325 // Update the power state CenRep key.
       
   326 // ---------------------------------------------------------------------------
       
   327 //
       
   328 void CBTEngSrvSettingsMgr::UpdateCenRepPowerKeyL( TBTPowerState aState )
       
   329     {
       
   330     TRACE_FUNC_ENTRY
       
   331     CRepository* cenrep = CRepository::NewLC( KCRUidBluetoothPowerState );
       
   332     // TBTPowerState power state type is inverted from TBTPowerStateValue...
       
   333     TBTPowerStateValue power = (TBTPowerStateValue) !aState;
       
   334     User::LeaveIfError( cenrep->Set( KBTPowerState, (TInt) power ) );
       
   335     CleanupStack::PopAndDestroy( cenrep );
       
   336     TRACE_FUNC_EXIT
       
   337     }
       
   338 
       
   339 
       
   340 // ---------------------------------------------------------------------------
       
   341 // ?implementation_description
       
   342 // ---------------------------------------------------------------------------
       
   343 //
       
   344 void CBTEngSrvSettingsMgr::SetVisibilityModeL( TBTVisibilityMode aMode, TInt aTime )
       
   345     {
       
   346     TRACE_FUNC_ARG( ( _L( "[aMode: %d" ), aMode ) )
       
   347     if ( aMode != EBTVisibilityModeNoScans && iEnterpriseEnablementMode == BluetoothFeatures::EDisabled )
       
   348         {
       
   349         TRACE_INFO( ( _L( "\tnot changing anything... Bluetooth is enterprise-IT-disabled" ) ) )
       
   350         User::Leave( KErrNotSupported );
       
   351         }
       
   352 
       
   353     TInt err = KErrNone;
       
   354     iServer->RemoveTimer( CBTEngServer::EScanModeTimer );
       
   355     if( aMode != EBTVisibilityModeNoScans )
       
   356         {
       
   357         CRepository* cenRep = CRepository::NewL( KCRUidBTEngPrivateSettings );
       
   358         err = cenRep->Set( KBTDiscoverable, aMode );
       
   359         delete cenRep;
       
   360         }
       
   361     if( !err && aMode == EBTVisibilityModeTemporary )
       
   362         {
       
   363             // We need TInt64 here, as the max. time in microseconds for the 
       
   364             // max. value (1 hour) is larger than KMaxTInt32.
       
   365         TInt64 timeMicroSec = MAKE_TINT64( 0, aTime );
       
   366         timeMicroSec = timeMicroSec * KMinutesInMicroSecs;
       
   367             // Queue callback to set the visibility back to hidden.
       
   368         iServer->QueueTimer( CBTEngServer::EScanModeTimer, (TInt64) timeMicroSec );
       
   369         aMode = EBTVisibilityModeGeneral;
       
   370         }
       
   371     else if( !err && iRestoreVisibility )
       
   372         {
       
   373             // The user overrides, do not restore visibility mode anymore.
       
   374         iRestoreVisibility = EFalse;
       
   375         }
       
   376     if( !err )
       
   377         {
       
   378         err = RProperty::Set( KUidSystemCategory, 
       
   379                                KPropertyKeyBluetoothSetScanningStatus, aMode );
       
   380         }
       
   381     TBool hiddenMode = ( aMode == EBTVisibilityModeHidden );
       
   382     if( !err && aMode != EBTVisibilityModeNoScans )
       
   383         {
       
   384             // In hidden mode, we only accept connections from paired devices.
       
   385         err = RProperty::Set( KUidSystemCategory, 
       
   386                                KPropertyKeyBluetoothSetAcceptPairedOnlyMode, 
       
   387                                hiddenMode );
       
   388         }
       
   389 
       
   390     User::LeaveIfError( err );  // To communicate the result to the client.
       
   391     TRACE_FUNC_EXIT
       
   392     }
       
   393 
       
   394 
       
   395 // ---------------------------------------------------------------------------
       
   396 // Timed visible mode has expired.
       
   397 // ---------------------------------------------------------------------------
       
   398 //
       
   399 void CBTEngSrvSettingsMgr::ScanModeTimerCompletedL()
       
   400     {
       
   401     TRACE_FUNC_ENTRY
       
   402     SetVisibilityModeL( EBTVisibilityModeHidden, 0 );
       
   403     TBTPowerState power = EBTOff;
       
   404     TInt err = GetHwPowerState( power );
       
   405     if( !err && power )
       
   406         {
       
   407         // Show a notification to the user
       
   408         TBTGenericInfoNotiferParamsPckg pckg;
       
   409         pckg().iMessageType = EBTVisibilityTimeout;
       
   410         
       
   411         RNotifier notifier;
       
   412         TInt err = notifier.Connect();
       
   413         if( !err )
       
   414             {
       
   415             err = notifier.StartNotifier( KBTGenericInfoNotifierUid, pckg );
       
   416             notifier.Close();
       
   417             }
       
   418         }
       
   419     TRACE_FUNC_RES( ( _L( "result: %d" ), err ) )
       
   420     }
       
   421 
       
   422 
       
   423 // ---------------------------------------------------------------------------
       
   424 // Check the secure simple pairing debug mode and turn it off if needed.
       
   425 // ---------------------------------------------------------------------------
       
   426 //
       
   427 void CBTEngSrvSettingsMgr::CheckSspDebugModeL( TBool aDebugMode )
       
   428     {
       
   429     TRACE_FUNC_ARG( ( _L( "SSP debug mode state %d" ), (TInt) aDebugMode ) )
       
   430     TBTPowerState pwr = EBTOff;
       
   431     TBool currentMode = EFalse;
       
   432     TInt err = RProperty::Get( KPropertyUidBluetoothCategory, 
       
   433                                 KPropertyKeyBluetoothGetSimplePairingDebugMode, 
       
   434                                 (TInt&) currentMode );
       
   435 #ifndef __WINS__
       
   436     err = iPowerMgr.GetPower( pwr, NULL ); // Treat error as power off.
       
   437 #else   //__WINS__
       
   438     pwr = iPowerState;
       
   439 #endif  //__WINS__
       
   440     if( err || pwr == EBTOff )
       
   441         {
       
   442         iServer->RemoveTimer( CBTEngServer::ESspDebugModeTimer );
       
   443             // Only set debug mode to off if it is on, to prevent a loop notifications.
       
   444         if( currentMode )
       
   445             {
       
   446             (void) RProperty::Set( KPropertyUidBluetoothCategory, 
       
   447                                     KPropertyKeyBluetoothSetSimplePairingDebugMode,
       
   448                                     (TInt) aDebugMode );
       
   449             }
       
   450             // In case of an error in getting the power state, turn BT off. 
       
   451             // If BT is already off, this call will be ignored.
       
   452         SetPowerStateL( EBTOff, EFalse );
       
   453         }
       
   454     else if( aDebugMode )
       
   455         {
       
   456             // Ignore if there already is a timer queued.
       
   457         if( !( iServer->IsTimerQueued( CBTEngServer::ESspDebugModeTimer ) ) )
       
   458             {
       
   459             iServer->QueueTimer( CBTEngServer::ESspDebugModeTimer, (TInt64) KBTEngSspDebugModeTimeout );
       
   460             err =  RProperty::Set(KPropertyUidBluetoothCategory, 
       
   461                                    KPropertyKeyBluetoothSetSimplePairingDebugMode, 
       
   462                                    (TInt) aDebugMode );
       
   463             }
       
   464         }
       
   465     else
       
   466         {
       
   467             // Power is on, and debug mode is set to off.
       
   468         TInt linkCount = 0;
       
   469         err = RProperty::Get( KPropertyUidBluetoothCategory, 
       
   470                                KPropertyKeyBluetoothGetPHYCount, linkCount );
       
   471         if( err || !linkCount )
       
   472             {
       
   473             (void) RProperty::Set(KPropertyUidBluetoothCategory, 
       
   474                                    KPropertyKeyBluetoothSetSimplePairingDebugMode,
       
   475                                    (TInt) aDebugMode );
       
   476             SetPowerStateL( EBTOff, EFalse );
       
   477             }
       
   478         else
       
   479             {
       
   480             // There are still existing connections, queue the
       
   481             // timer again for half the period.
       
   482             TInt64 interval = KBTEngSspDebugModeTimeout / 2;
       
   483             iServer->QueueTimer( CBTEngServer::ESspDebugModeTimer, interval );
       
   484             }
       
   485         }
       
   486     TRACE_FUNC_EXIT
       
   487     }
       
   488 
       
   489 // ---------------------------------------------------------------------------
       
   490 // A session will be ended, completes the pending request for this session.
       
   491 // ---------------------------------------------------------------------------
       
   492 //
       
   493 void CBTEngSrvSettingsMgr::SessionClosed( CSession2* aSession )
       
   494     {
       
   495     TRACE_FUNC_ARG( ( _L( " session %x"), aSession ) )
       
   496     if ( !iMessage.IsNull() && iMessage.Session() == aSession )
       
   497         {
       
   498         iMessage.Complete( KErrCancel );
       
   499         }
       
   500     TRACE_FUNC_EXIT
       
   501     }
       
   502 
       
   503 // ---------------------------------------------------------------------------
       
   504 // Check the power state and if BT gets turned off automatically.
       
   505 // This method is invoked either when the timer has expired, or
       
   506 // if there are no more connections while the timer was running.
       
   507 // ---------------------------------------------------------------------------
       
   508 //
       
   509 void CBTEngSrvSettingsMgr::CheckAutoPowerOffL()
       
   510     {
       
   511     TRACE_FUNC_ENTRY
       
   512     if ( iAutoOffClients > 0 )
       
   513         {
       
   514         TRACE_INFO( ( _L( "[CBTEngServer]\t iAutoOffClients %d"), iAutoOffClients ) )
       
   515         return;
       
   516         }
       
   517     TInt linkCount = 0;
       
   518     TInt err = RProperty::Get( KPropertyUidBluetoothCategory, 
       
   519                                 KPropertyKeyBluetoothGetPHYCount, linkCount );
       
   520     if( !err && !linkCount )
       
   521         {
       
   522         TRACE_INFO( ( _L( "[CBTEngServer]\t SetPowerStateL( EBTOff, EFalse );")))
       
   523         SetPowerStateL( EBTOff, EFalse );
       
   524         }
       
   525     else
       
   526         {
       
   527         if( iRestoreVisibility )
       
   528             {
       
   529                 // Set visibility mode back to the value selected by the user.
       
   530             SetVisibilityModeL( EBTVisibilityModeGeneral, 0 );
       
   531             iRestoreVisibility = EFalse;
       
   532             }
       
   533             // show note if non-audio connection exists
       
   534         if ( !iServer->PluginManager()->CheckAudioConnectionsL() )
       
   535             {
       
   536             RNotifier notifier;
       
   537             TInt err = notifier.Connect();
       
   538             if( !err )
       
   539                 {
       
   540                 TRequestStatus status;
       
   541                 TBTGenericInfoNotiferParamsPckg pckg;
       
   542                 pckg().iMessageType = EBTStayPowerOn;
       
   543                 TBuf8<sizeof(TInt)> result;
       
   544                 //notifier.StartNotifier( KBTGenericInfoNotifierUid, pckg, result );
       
   545                 notifier.StartNotifierAndGetResponse( status, 
       
   546                                                   KBTGenericInfoNotifierUid, 
       
   547                                                   pckg, result );   // Reply buffer not used.
       
   548                 User::WaitForRequest( status );
       
   549                 notifier.Close();
       
   550                 }
       
   551             }
       
   552         iAutoOffClients = 0;
       
   553         iAutoSwitchOff = EFalse;
       
   554         TCallBack cb;
       
   555         iServer->BasebandConnectionManager()->SetAutoSwitchOff( EFalse, cb );
       
   556         }
       
   557     TRACE_FUNC_EXIT 
       
   558     }
       
   559 
       
   560 
       
   561 // ---------------------------------------------------------------------------
       
   562 // The method is called when BT stack scanning mode P&S key is changed
       
   563 // ---------------------------------------------------------------------------
       
   564 //
       
   565 void CBTEngSrvSettingsMgr::UpdateVisibilityModeL( TInt aStackScanMode )
       
   566     {
       
   567     TRACE_FUNC_ARG( ( _L( "[aStackScanMode: %d" ), aStackScanMode ) )
       
   568     TBTVisibilityMode currentMode;
       
   569 
       
   570     CRepository* cenRep = CRepository::NewLC( KCRUidBTEngPrivateSettings );
       
   571     User::LeaveIfError( cenRep->Get( KBTDiscoverable, (TInt&) currentMode ) );
       
   572 
       
   573         // In case we are in temp visibility mode, we cannot always know whether the BT stack
       
   574         // scan mode key was set by some external party or by us in SetVisibilityModeL above.
       
   575         // Therefore we cannot stop the timer in case aMode is EBTVisibilityModeGeneral and 
       
   576         // currentmode is EBTVisibilityModeTemporary
       
   577     if( !( currentMode == EBTVisibilityModeTemporary && aStackScanMode == EBTVisibilityModeGeneral ) )
       
   578         {
       
   579             // Cancel the timer and queue it again if needed.
       
   580         iServer->RemoveTimer( CBTEngServer::EScanModeTimer );
       
   581         if( currentMode != aStackScanMode )
       
   582             {
       
   583             if( aStackScanMode == EPageScanOnly || aStackScanMode == EInquiryAndPageScan )
       
   584                 {
       
   585                 User::LeaveIfError( cenRep->Set( KBTDiscoverable, aStackScanMode ) );
       
   586                 }
       
   587             else if( aStackScanMode == EInquiryScanOnly )
       
   588                 {
       
   589                     // We don't support ENoScansEnabled nor EInquiryScanOnly mode
       
   590                     // -> Consider these as same as Hidden 
       
   591                 User::LeaveIfError( cenRep->Set( KBTDiscoverable, EBTVisibilityModeHidden ) );
       
   592                 }
       
   593             else if( aStackScanMode == ENoScansEnabled )
       
   594                 {
       
   595                 //We don't change KBTDiscoverable here, because ENoScansEnabled
       
   596                 //indicates BT/SYSTEM shutdown is happening
       
   597                 }
       
   598             }
       
   599         }
       
   600     SetUiIndicatorsL();
       
   601     CleanupStack::PopAndDestroy( cenRep );
       
   602     TRACE_FUNC_EXIT
       
   603     }
       
   604 
       
   605 
       
   606 // ---------------------------------------------------------------------------
       
   607 // Set Device Under Test mode.
       
   608 // ---------------------------------------------------------------------------
       
   609 //
       
   610 void CBTEngSrvSettingsMgr::SetDutMode( TInt aDutMode )
       
   611     {
       
   612     TRACE_FUNC_ARG( ( _L( "DUT mode %d" ), aDutMode ) )
       
   613 
       
   614     if (aDutMode == EBTDutOff)
       
   615         {
       
   616         return;
       
   617         }
       
   618 
       
   619     TInt powerState = EBTOff;
       
   620     CRepository* cenrep = NULL;
       
   621     
       
   622     TRAPD(err, cenrep = CRepository::NewL(KCRUidBluetoothPowerState));
       
   623     
       
   624     if (!err && cenrep)
       
   625         {
       
   626         cenrep->Get(KBTPowerState, powerState);
       
   627         delete cenrep;
       
   628         cenrep = NULL;
       
   629         }
       
   630     else
       
   631         {
       
   632         return;
       
   633         }
       
   634 
       
   635     if (powerState == EBTOn)
       
   636         {
       
   637 
       
   638 #ifndef __WINS__
       
   639         RBluetoothDutMode dutMode;
       
   640         TInt err = dutMode.Open();
       
   641         TRACE_FUNC_ARG( ( _L( "Open DUT mode handle err %d" ), err) )
       
   642         if(!err) 
       
   643             {
       
   644             dutMode.ActivateDutMode();
       
   645             dutMode.Close();
       
   646             }
       
   647 #endif  //__WINS__                        
       
   648         }
       
   649     }
       
   650 
       
   651 
       
   652 // ---------------------------------------------------------------------------
       
   653 // From class MBTEngActiveObserver.
       
   654 // Callback to notify that an outstanding request has completed.
       
   655 // ---------------------------------------------------------------------------
       
   656 //
       
   657 void CBTEngSrvSettingsMgr::RequestCompletedL( CBTEngActive* aActive, TInt aId, TInt aStatus )
       
   658     {
       
   659     __ASSERT_ALWAYS( aId == KBTEngSettingsActive, PanicServer( EBTEngPanicCorrupt ) );
       
   660     TRACE_FUNC_ENTRY
       
   661     (void) aActive;
       
   662     if ( aStatus != KErrNone && aStatus != KErrAlreadyExists && aStatus != KErrCancel )
       
   663         {
       
   664         // Something went wrong, so we turn BT off again.
       
   665         SetPowerStateL( EBTOff, EFalse );
       
   666         }
       
   667     else
       
   668         {
       
   669         // Write CoD only when the hardware has fully powered up.
       
   670         TBTPowerState currState ( EBTOff );
       
   671         (void) GetHwPowerState( currState );
       
   672         if ( currState == EBTOn )
       
   673             {
       
   674             SetClassOfDeviceL();
       
   675 #ifndef SETLOCALNAME 
       
   676             // the macro SETLOCALNAME is used as a workaround to tackle the BT name 
       
   677             // could not be saved to BT chip before chip initialization completed for the first time,
       
   678             // which is one of the regression after improving the BT boot up time. 
       
   679             // To be removed once the final solution is in place. 
       
   680             CBTEngSettings* settings = CBTEngSettings::NewL();
       
   681             TBTDeviceName localName;           
       
   682             localName.Zero();
       
   683             TInt err = settings->GetLocalName(localName);
       
   684             if (err == KErrNone)
       
   685                 {
       
   686                 settings->SetLocalName(localName);
       
   687                 }
       
   688             delete settings;
       
   689 #endif
       
   690             }
       
   691         }
       
   692     if ( !iMessage.IsNull())
       
   693         {
       
   694         iMessage.Complete( aStatus );
       
   695         }
       
   696     TRACE_FUNC_EXIT
       
   697     }
       
   698 
       
   699 
       
   700 // ---------------------------------------------------------------------------
       
   701 // From class MBTEngActiveObserver.
       
   702 // Callback to notify that an error has occurred in RunL.
       
   703 // ---------------------------------------------------------------------------
       
   704 //
       
   705 void CBTEngSrvSettingsMgr::HandleError( CBTEngActive* aActive, TInt aId, TInt aError )
       
   706     {
       
   707     (void) aActive;
       
   708     (void) aId;
       
   709     if ( !iMessage.IsNull())
       
   710         {
       
   711         iMessage.Complete( aError );
       
   712         }
       
   713     }
       
   714 
       
   715 
       
   716 // ---------------------------------------------------------------------------
       
   717 // Loads the BT Power Manager; leaves if it cannot be loaded.
       
   718 // ---------------------------------------------------------------------------
       
   719 //
       
   720 void CBTEngSrvSettingsMgr::LoadBTPowerManagerL()
       
   721     {
       
   722     TRACE_FUNC_ENTRY
       
   723     TRACE_INFO( ( _L( "[CBTEngSrvSettingsMgr]\t Using HCI API v2 power manager" ) ) )
       
   724     User::LeaveIfError( iPowerMgr.Open() );
       
   725 #ifndef __WINS__
       
   726     iPowerMgr.SetPower( EBTOff, NULL, iActive->RequestStatus() );
       
   727     User::WaitForRequest( iActive->RequestStatus() );
       
   728     TInt status = ( iActive->RequestStatus().Int() == KErrAlreadyExists ? KErrNone : iActive->RequestStatus().Int() ); 
       
   729     User::LeaveIfError( status );
       
   730 #else   //__WINS__
       
   731     iPowerState = EBTOff;
       
   732 #endif  //__WINS__
       
   733     TRACE_FUNC_EXIT
       
   734     }
       
   735 
       
   736 
       
   737 // ---------------------------------------------------------------------------
       
   738 // ?implementation_description
       
   739 // ---------------------------------------------------------------------------
       
   740 //
       
   741 void CBTEngSrvSettingsMgr::SetUiIndicatorsL()
       
   742     {
       
   743     TRACE_FUNC_ENTRY
       
   744     TBTPowerStateValue powerState = EBTPowerOff;
       
   745     TBTVisibilityMode visibilityMode = EBTVisibilityModeHidden;
       
   746     CRepository* cenrep = NULL;
       
   747     TInt phys = 0;
       
   748     TInt connecting = 0;
       
   749 
       
   750     cenrep = CRepository::NewLC( KCRUidBluetoothPowerState );
       
   751     User::LeaveIfError( cenrep->Get( KBTPowerState, (TInt&) powerState ) );
       
   752     CleanupStack::PopAndDestroy( cenrep );
       
   753     
       
   754     if( powerState == EBTPowerOff )
       
   755         {
       
   756         SetIndicatorStateL( EAknIndicatorBluetoothModuleOn, EAknIndicatorStateOff );
       
   757         SetIndicatorStateL( EAknIndicatorBluetooth, EAknIndicatorStateOff );
       
   758         SetIndicatorStateL( EAknIndicatorBluetoothModuleOnVisible, EAknIndicatorStateOff );
       
   759         SetIndicatorStateL( EAknIndicatorBluetoothVisible, EAknIndicatorStateOff );
       
   760         }
       
   761     else
       
   762         {
       
   763         // Power is on.
       
   764         RProperty::Get( KPropertyUidBluetoothCategory, KPropertyKeyBluetoothPHYCount, phys );
       
   765         RProperty::Get( KPropertyUidBluetoothCategory, KPropertyKeyBluetoothConnecting, connecting );
       
   766         
       
   767         cenrep = CRepository::NewLC( KCRUidBTEngPrivateSettings );
       
   768         User::LeaveIfError( cenrep->Get( KBTDiscoverable, (TInt&) visibilityMode ) );
       
   769         CleanupStack::PopAndDestroy( cenrep );
       
   770         
       
   771         if( visibilityMode == EBTVisibilityModeHidden )
       
   772             {
       
   773              if ( connecting ) // BT connecting and hidden
       
   774                 {
       
   775                 SetIndicatorStateL( EAknIndicatorBluetoothModuleOn, EAknIndicatorStateOff );
       
   776                 SetIndicatorStateL( EAknIndicatorBluetooth, EAknIndicatorStateAnimate );
       
   777                 }
       
   778             else if ( phys > 0 ) // BT connection active and hidden     
       
   779                 {
       
   780                 SetIndicatorStateL( EAknIndicatorBluetoothModuleOn, EAknIndicatorStateOff );
       
   781                 SetIndicatorStateL( EAknIndicatorBluetooth, EAknIndicatorStateOn );
       
   782                 }
       
   783             else  // BT connection not active and hidden
       
   784                 {
       
   785                 SetIndicatorStateL( EAknIndicatorBluetoothModuleOn, EAknIndicatorStateOn );
       
   786                 SetIndicatorStateL( EAknIndicatorBluetooth, EAknIndicatorStateOff );
       
   787                 }
       
   788             SetIndicatorStateL( EAknIndicatorBluetoothModuleOnVisible, EAknIndicatorStateOff );
       
   789             SetIndicatorStateL( EAknIndicatorBluetoothVisible, EAknIndicatorStateOff );
       
   790             }           
       
   791         else if( visibilityMode == EBTVisibilityModeGeneral || visibilityMode == EBTVisibilityModeTemporary )
       
   792             {     
       
   793             if ( connecting ) // BT connecting and visible
       
   794                 {
       
   795                 SetIndicatorStateL( EAknIndicatorBluetoothModuleOnVisible, EAknIndicatorStateOff );
       
   796                 SetIndicatorStateL( EAknIndicatorBluetoothVisible, EAknIndicatorStateAnimate );
       
   797                 }
       
   798             else if ( phys > 0 ) // BT connection active and visible 
       
   799                 {
       
   800                 SetIndicatorStateL( EAknIndicatorBluetoothModuleOnVisible, EAknIndicatorStateOff );
       
   801                 SetIndicatorStateL( EAknIndicatorBluetoothVisible, EAknIndicatorStateOn );
       
   802                 }
       
   803             else  // BT connection not active and visible
       
   804                 {
       
   805                 SetIndicatorStateL( EAknIndicatorBluetoothModuleOnVisible, EAknIndicatorStateOn );
       
   806                 SetIndicatorStateL( EAknIndicatorBluetoothVisible, EAknIndicatorStateOff );
       
   807                 }
       
   808             SetIndicatorStateL( EAknIndicatorBluetoothModuleOn, EAknIndicatorStateOff );
       
   809             SetIndicatorStateL( EAknIndicatorBluetooth, EAknIndicatorStateOff );
       
   810             }
       
   811         }
       
   812     TRACE_FUNC_EXIT
       
   813     }
       
   814 
       
   815 
       
   816 // ---------------------------------------------------------------------------
       
   817 // ?implementation_description
       
   818 // ---------------------------------------------------------------------------
       
   819 //
       
   820 void CBTEngSrvSettingsMgr::SetIndicatorStateL( const TInt aIndicator, const TInt aState )
       
   821     {
       
   822     CAknSmallIndicator* indicator = CAknSmallIndicator::NewLC( TUid::Uid( aIndicator ) );
       
   823     indicator->SetIndicatorStateL( aState );
       
   824     CleanupStack::PopAndDestroy( indicator ); //indicator
       
   825     }
       
   826 
       
   827 
       
   828 // ---------------------------------------------------------------------------
       
   829 // Gets the current HW power state.
       
   830 // For now this is a separate method to isolate the different variations.
       
   831 // ---------------------------------------------------------------------------
       
   832 //
       
   833 TInt CBTEngSrvSettingsMgr::GetHwPowerState( TBTPowerState& aState )
       
   834     {
       
   835     TRACE_FUNC_ENTRY
       
   836     TInt err = KErrNone;
       
   837     
       
   838 #ifndef __WINS__
       
   839     err = iPowerMgr.GetPower( aState, NULL );
       
   840 #else   //__WINS__
       
   841     aState = iPowerState;
       
   842 #endif  //__WINS__
       
   843     TRACE_FUNC_ARG( ( _L( "Power state is %d, result %d" ), (TInt) aState, err ) )
       
   844     return err;
       
   845     }
       
   846 
       
   847 // ---------------------------------------------------------------------------
       
   848 // Check the power state and if BT gets turned off automatically.
       
   849 // ---------------------------------------------------------------------------
       
   850 //
       
   851 void CBTEngSrvSettingsMgr::CheckTemporaryPowerStateL( TBTPowerState& aCurrentState, 
       
   852     TBTPowerState aNewState, TBool aTemporary )
       
   853     {
       
   854     TRACE_FUNC_ENTRY
       
   855     User::LeaveIfError( GetHwPowerState( aCurrentState ) );
       
   856     if( !aTemporary )
       
   857         {
       
   858             // Force the new power state, so clear all auto switch off flags.
       
   859             // If power is off, this will anyway be ignored.
       
   860         iAutoOffClients = 0;
       
   861         iAutoSwitchOff = EFalse;
       
   862         TCallBack cb;
       
   863         iServer->BasebandConnectionManager()->SetAutoSwitchOff( EFalse, cb );
       
   864         if( iRestoreVisibility && aCurrentState == EBTOn )
       
   865             {
       
   866                 // Set visibility mode back to the value selected by the user.
       
   867             SetVisibilityModeL( EBTVisibilityModeGeneral, 0 );
       
   868             iRestoreVisibility = EFalse;
       
   869             }
       
   870         }
       
   871     else
       
   872         {
       
   873         if( aCurrentState == aNewState )
       
   874             {
       
   875             if( iAutoSwitchOff && aNewState == EBTOn )
       
   876                 {
       
   877                 iAutoOffClients++;
       
   878                 iServer->RemoveTimer( CBTEngServer::EAutoPowerOffTimer );
       
   879                 }
       
   880             }
       
   881         else if( iAutoSwitchOff || aNewState == EBTOn )
       
   882             {
       
   883             aNewState == EBTOff ? iAutoOffClients-- : iAutoOffClients++;
       
   884             iAutoSwitchOff = ETrue;
       
   885             if( aNewState == EBTOff && iAutoOffClients <= 0 )
       
   886                 {
       
   887                 TCallBack powerOffCb( CBTEngServer::AutoPowerOffCallBack, iServer );
       
   888                 iServer->BasebandConnectionManager()->SetAutoSwitchOff( ETrue, powerOffCb );
       
   889                 TInt64 interval = KBTEngBtAutoOffTimeout;
       
   890                 iServer->QueueTimer( CBTEngServer::EAutoPowerOffTimer, interval );
       
   891                 }
       
   892             else if( aNewState == EBTOn )
       
   893                 {
       
   894                 CRepository* cenRep = CRepository::NewLC( KCRUidBTEngPrivateSettings );
       
   895                 TBTVisibilityMode visibility = EBTVisibilityModeGeneral;
       
   896                 TInt err = cenRep->Get( KBTDiscoverable, (TInt&) visibility );
       
   897                 CleanupStack::PopAndDestroy( cenRep );
       
   898                 if( !err && visibility == EBTVisibilityModeGeneral )
       
   899                     {
       
   900                     SetVisibilityModeL( EBTVisibilityModeHidden, 0 );
       
   901                     iRestoreVisibility = ETrue;
       
   902                    }
       
   903                 iServer->RemoveTimer( CBTEngServer::EAutoPowerOffTimer );
       
   904                 }
       
   905             }
       
   906         }
       
   907     if( iAutoOffClients < 0 )
       
   908         {
       
   909         iAutoOffClients = 0;
       
   910         }
       
   911     TRACE_FUNC_EXIT 
       
   912     }
       
   913 
       
   914 
       
   915 // ---------------------------------------------------------------------------
       
   916 // Set the Class of Device.
       
   917 // ---------------------------------------------------------------------------
       
   918 //
       
   919 void CBTEngSrvSettingsMgr::SetClassOfDeviceL()
       
   920     {
       
   921     TRACE_FUNC_ENTRY
       
   922     TUint16 serviceClass = KCoDDefaultServiceClass;
       
   923         // Check from feature manager if stereo audio is enabled.
       
   924     FeatureManager::InitializeLibL();
       
   925     TBool supported = FeatureManager::FeatureSupported( KFeatureIdBtStereoAudio );
       
   926     FeatureManager::UnInitializeLib();
       
   927     if( supported )
       
   928         {
       
   929         // A2DP spec says we should set this bit as we are a SRC
       
   930         serviceClass |= EMajorServiceCapturing;
       
   931         }
       
   932         // These values may nayway be overridden by HCI
       
   933     TBTDeviceClass cod( serviceClass, KCoDDefaultMajorDeviceClass, 
       
   934                          KCoDDefaultMinorDeviceClass );
       
   935         // Ignore error, it is non-critical
       
   936     (void) RProperty::Set( KPropertyUidBluetoothControlCategory, 
       
   937                             KPropertyKeyBluetoothSetDeviceClass, cod.DeviceClass() );
       
   938     TRACE_FUNC_EXIT
       
   939     }