1 /*

     2 * Copyright (c) 2007-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:  CCCHServiceHandler implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <cchclientserver.h>

    21 #include <spnotifychange.h>

    22 

    23 #include "cchservicehandler.h"

    24 #include "cchserverbase.h"

    25 #include "cchspshandler.h"

    26 #include "cchlogger.h"

    27 #include "cchpluginhandler.h"

    28 #include "cchuihandler.h"

    29 #include "cchconnmonhandler.h"

    30 #include "cchwlanextension.h"

    31 #include "cchcommdbwatcher.h"

    32 #include "cchcommdbwatcherobserver.h"

    33 

    34 // EXTERNAL DATA STRUCTURES

    35 // None

    36 

    37 // EXTERNAL FUNCTION PROTOTYPES

    38 // None

    39 

    40 // CONSTANTS

    41 

    42 const TInt KConnectionRecoveryMaxTries = 5;

    43 

    44 const TInt KCCHFirstRecovery    = 15000000;

    45 const TInt KCCHSecondRecovery   = 15000000;

    46 const TInt KCCHThirdRecovery    = 30000000;

    47 const TInt KCCHFourthRecovery   = 60000000;

    48 const TInt KCCHFifthRecovery    = 60000000;

    49 

    50 const TInt KCCHPluginUnloadTimeout = 5000000;

    51 

    52 const TInt KCCHHandleNotifyDelay = 1000000;

    53 

    54 // MACROS

    55 // None

    56 

    57 // LOCAL CONSTANTS AND MACROS

    58 // None

    59 

    60 // MODULE DATA STRUCTURES

    61 // None

    62 

    63 // LOCAL FUNCTION PROTOTYPES

    64 // None

    65 

    66 // FORWARD DECLARATIONS

    67 // None.

    68 

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

    70 

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

    72 

    73 // ---------------------------------------------------------------------------

    74 // CCCHServiceHandler::CCCHServiceHandler

    75 // C++ default constructor can NOT contain any code, that might leave.

    76 // ---------------------------------------------------------------------------

    77 //

    78 CCCHServiceHandler::CCCHServiceHandler( CCCHServerBase& aServer ) :

    79     iServer( aServer ),

    80     iConnectionRecoveryTry( 0 ),

    81     iCancelNotify( ETrue ) 

    82     {

    83     // No implementation required

    84     }

    85 

    86 // ---------------------------------------------------------------------------

    87 // CCCHServiceHandler::ConstructL

    88 // Symbian 2nd phase constructor can leave.

    89 // ---------------------------------------------------------------------------

    90 //

    91 void CCCHServiceHandler::ConstructL()

    92     {

    93     iNotifier = CSPNotifyChange::NewL( *this );

    94     iCchUIHandler = CCchUIHandler::NewL( iServer, *this );

    95     iConnectionRecoveryTimer = CPeriodic::NewL( CPeriodic::EPriorityStandard );

    96     iCommDbWatcher = CCCHCommDbWatcher::NewL( *this );

    97     iPluginUnloadTimer = CPeriodic::NewL( CPeriodic::EPriorityStandard );

    98     iHandleNotifyDelayTimer = CPeriodic::NewL( CPeriodic::EPriorityStandard );

    99     iRecoveryInterval.Append( KCCHFirstRecovery );

   100     iRecoveryInterval.Append( KCCHSecondRecovery );

   101     iRecoveryInterval.Append( KCCHThirdRecovery );

   102     iRecoveryInterval.Append( KCCHFourthRecovery );

   103     iRecoveryInterval.Append( KCCHFifthRecovery );

   104     iWlanExtension = CCchWlanExtension::NewL( );

   105     }

   106 

   107 // ---------------------------------------------------------------------------

   108 // CCCHServiceHandler::NewL

   109 // Two-phased constructor.

   110 // ---------------------------------------------------------------------------

   111 //

   112 CCCHServiceHandler* CCCHServiceHandler::NewL( CCCHServerBase& aServer )

   113     {

   114     CCCHServiceHandler* self = CCCHServiceHandler::NewLC( aServer );

   115     CleanupStack::Pop( self );

   116     return self;

   117     }

   118 

   119 // ---------------------------------------------------------------------------

   120 // CCCHServiceHandler::NewLC

   121 // Two-phased constructor.

   122 // ---------------------------------------------------------------------------

   123 //

   124 CCCHServiceHandler* CCCHServiceHandler::NewLC( CCCHServerBase& aServer )

   125     {

   126     CCCHServiceHandler* self = new (ELeave) CCCHServiceHandler( aServer );

   127     CleanupStack::PushL( self );

   128     self->ConstructL();

   129     return self;

   130     }

   131 

   132 // Destructor

   133 CCCHServiceHandler::~CCCHServiceHandler()

   134     {

   135     if ( iCchUIHandler )

   136         {

   137         iCchUIHandler->Destroy();

   138         }

   139 

   140     delete iWlanExtension;

   141     delete iConnectionRecoveryTimer;

   142     delete iPluginUnloadTimer;

   143     delete iHandleNotifyDelayTimer;

   144     delete iCommDbWatcher;

   145 

   146     if( iNotifier )

   147         {

   148         iNotifier->Cancel();

   149         delete iNotifier;

   150         iNotifier = NULL;    

   151         }

   152 

   153     iServiceIds.Close();

   154     iServer.PluginHandler().RemoveServiceNotifier( this );

   155     iServices.ResetAndDestroy();

   156     iServicesInRecovery.Close();

   157     iRecoveryInterval.Close();

   158     }

   159 

   160 // ---------------------------------------------------------------------------

   161 // CCCHServiceHandler::InitServiceHandlerL

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

   163 // ---------------------------------------------------------------------------

   164 //

   165 void CCCHServiceHandler::InitServiceHandlerL()

   166     {

   167     CCHLOGSTRING2( "CCCHServiceHandler::InitServiceHandlerL [0x%x]: IN",this );

   168     

   169     RArray<TUint> serviceIds;

   170     CleanupClosePushL( serviceIds );

   171     iServer.SPSHandler().GetServiceIdsL( serviceIds );

   172     for ( TInt i( 0 ); i < serviceIds.Count(); i++ )

   173         {        

   174         if ( KErrNotFound == FindService( serviceIds[ i ] ) )

   175             {

   176             TCCHService service;

   177             TRAPD( error, iServer.SPSHandler().GetServiceInfoL( 

   178                 serviceIds[ i ], service ) );

   179             if ( KErrNone == error )

   180                 {

   181                 AddServiceL( service );    

   182                 }                    

   183             }

   184         }

   185     CleanupStack::PopAndDestroy( &serviceIds );

   186     // Subscribe to service change notifies    

   187     EnableNotifyChange();

   188     

   189     CCHLOGSTRING( "CCCHServiceHandler::InitServiceHandlerL: OUT" );

   190     }

   191 

   192 // ---------------------------------------------------------------------------

   193 // CCCHServiceHandler::AddServiceL

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

   195 // ---------------------------------------------------------------------------

   196 //

   197 void CCCHServiceHandler::AddServiceL( TCCHService& aService )

   198     {

   199     CCHLOGSTRING( "CCCHServiceHandler::AddServiceL: IN" );

   200     

   201     CCCHServiceInfo* cchServiceInfo = CCCHServiceInfo::NewLC( iServer );

   202     cchServiceInfo->SetServiceId( aService.iServiceId );

   203     cchServiceInfo->SetName( aService.iServiceName );

   204     CCHLOGSTRING2( "CCCHServiceHandler::AddServiceL: adding service with %d subservices",aService.iSubservices.Count() );

   205     for ( TInt i( 0 ); i < aService.iSubservices.Count(); i++ )

   206         {

   207         cchServiceInfo->AddSubserviceL( aService.iSubservices[ i ] );

   208         }

   209         

   210     CleanupStack::Pop( cchServiceInfo );

   211     iServices.Append( cchServiceInfo );

   212     

   213     CCHLOGSTRING( "CCCHServiceHandler::AddServiceL: OUT" );

   214     }

   215 

   216 // ---------------------------------------------------------------------------

   217 // CCCHServiceHandler::UpdateL

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

   219 // ---------------------------------------------------------------------------

   220 //

   221 void CCCHServiceHandler::UpdateL( TBool aReadSettingTable )

   222     {

   223     CCHLOGSTRING( "CCCHServiceHandler::UpdateL: IN" );

   224     

   225     // Read settings from service table

   226     if ( aReadSettingTable )

   227         {

   228         RArray<TUint> serviceIds;

   229         CleanupClosePushL( serviceIds );

   230         

   231         TInt index( KErrNotFound );

   232         iServer.SPSHandler().GetServiceIdsL( serviceIds );

   233         

   234         for ( TInt i( 0 ); i < serviceIds.Count(); i++ )

   235             {        

   236             index = FindService( serviceIds[ i ] );

   237             if ( KErrNotFound != index )

   238                 {

   239                 iServices[ index ]->UpdateL( ETrue );

   240                 }

   241             else

   242                 {

   243                 CCHLOGSTRING2

   244                     ( "CCCHSeviceHandler::UpdateL: \

   245                         New service found: ServiceId %d", serviceIds[ i ] );

   246                 TCCHService service;

   247                 TRAPD( error, iServer.SPSHandler().GetServiceInfoL( 

   248                     serviceIds[ i ], service ) );

   249                 if ( KErrNone == error )

   250                     {

   251                     AddServiceL( service );

   252                     }                

   253                 }

   254             }

   255         if ( serviceIds.Count() < iServices.Count() )

   256             {

   257             // Remove service's which does not exist anymore            

   258             for ( TInt i( 0 ); i < iServices.Count(); i++ )

   259                 {            

   260                 if ( KErrNotFound == serviceIds.Find( 

   261                     iServices[ i ]->GetServiceId( ) ) )

   262                     {

   263                     CCHLOGSTRING2

   264                         ( "CCCHSeviceHandler::UpdateL: \

   265                         service removed: ServiceId %d", 

   266                         iServices[ i ]->GetServiceId() );

   267                     delete iServices[ i ];

   268                     iServices.Remove( i );

   269                     i--;

   270                     StartPluginUnloadTimer( );

   271                     }

   272                 }

   273             }

   274         CleanupStack::PopAndDestroy( &serviceIds );

   275         }

   276     else

   277         {

   278         for ( TInt i( 0 ); i < iServices.Count(); i++ )

   279             {

   280             iServices[ i ]->UpdateL();

   281             }    

   282         }

   283     

   284     CCHLOGSTRING( "CCCHServiceHandler::UpdateL: OUT" );

   285     }

   286 

   287 // ---------------------------------------------------------------------------

   288 // CCCHServiceHandler::IsStartupFlagSet

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

   290 // ---------------------------------------------------------------------------

   291 //

   292 TBool CCCHServiceHandler::IsStartupFlagSet() const

   293     {

   294     TBool ret( EFalse );

   295 

   296     for ( TInt i( 0 ); i < iServices.Count() && !ret; i++ )

   297         {

   298         ret = iServices[ i ]->StartupFlagSet();

   299         }

   300         

   301     CCHLOGSTRING2( "CCCHServiceHandler::IsStartupFlagSet: %d", ret );

   302     return ret;

   303     }

   304 

   305 

   306 // ---------------------------------------------------------------------------

   307 // CCCHServiceHandler::IsRecoveryNeeded

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

   309 // ---------------------------------------------------------------------------

   310 //

   311 TBool CCCHServiceHandler::IsRecoveryNeeded( 

   312                                const TCCHSubserviceState aState, 

   313                                TInt aError )

   314     {

   315     TBool recover( EFalse );

   316     CCHLOGSTRING( "CCCHServiceHandler::IsRecoveryNeeded: IN" );

   317     if( !iServer.FeatureManager().OfflineMode() &&

   318         ECCHConnecting == aState && ( 

   319         KCCHErrorNetworkLost == aError || 

   320         KCCHErrorServiceNotResponding == aError ) &&

   321         !iConnectionRecoveryTimer->IsActive() )

   322         {

   323         recover = ETrue;            

   324         }

   325     CCHLOGSTRING2( "CCCHServiceHandler::IsRecoveryNeeded: OUT, value=%d", recover );

   326     return recover;

   327     }

   328 

   329 // ---------------------------------------------------------------------------

   330 // CCCHServiceHandler::StateChangedL

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

   332 // ---------------------------------------------------------------------------

   333 //

   334 void CCCHServiceHandler::StateChangedL( const TUint aServiceId,

   335                                         const TCCHSubserviceType aType,

   336                                         const TCCHSubserviceState aState,

   337                                         const TInt aError )

   338     {

   339     

   340     CCHLOGSTRING( "CCCHServiceHandler::StateChanged: IN" );

   341     CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service id;        %d",aServiceId );

   342     CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service type;      %d",aType );

   343     CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service new state; %d",aState );

   344     CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service error;     %d",aError );

   345     TInt index( FindService( aServiceId ) );

   346     if ( KErrNotFound != index )

   347         {

   348         iServices[ index ]->SetErrorL( aType, aError );

   349         iServices[ index ]->SetStateL( aType, aState );

   350         //toggle voip indicator & emergency note if needed

   351         if( ECCHVoIPSub == aType )

   352             {

   353             iCchUIHandler->UpdateUI( );

   354             }

   355         

   356         if ( ECCHEnabled == aState && !iCchUIHandler->IsCostWarningSeen() )

   357             {

   358             // Check for possible first usage of GPRS (roaming cost warning)

   359             TServiceConnectionInfo serviceConnInfo( aServiceId, aType, 0, 0 );

   360             GetConnectionInfo( serviceConnInfo );

   361             

   362             if ( serviceConnInfo.iIapId )

   363                 {

   364                 // Stop monitoring connectivity changes and take new connections

   365                 RArray<TUint> iaps;

   366                 CleanupClosePushL( iaps );

   367                 TBool gprs( EFalse );

   368                 iServer.ConnMonHandler().StopMonitoringConnectionChanges( iaps );

   369                 

   370                 // Are we connected via VPN

   371                 if ( iCommDbWatcher->IsVpnApL( serviceConnInfo.iIapId ) )

   372                     {

   373                     // Remove iaps whom are not linked to vpn(snap or iap)

   374                     TRAP_IGNORE( iCommDbWatcher->RemoveOtherThanVpnIapsL( 

   375                         iaps, serviceConnInfo.iIapId ) );

   376                                 

   377                     for ( TInt i( 0 ); i < iaps.Count(); i++ )

   378                         {

   379                         CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: new connections: %d",iaps[ i ] );

   380                         

   381                         // if any new connection is gprs connection show note if not showed already

   382                         if( !iCommDbWatcher->IsVpnApL( iaps[ i ] ) && !iCommDbWatcher->IsWlanApL( iaps[ i ] ) )

   383                             {

   384                             gprs = ETrue;

   385                             break;

   386                             }

   387                         }

   388                     }

   389                 else if( !iCommDbWatcher->IsWlanApL( serviceConnInfo.iIapId ) )

   390                     {      

   391                     gprs = ETrue;

   392                     }

   393                 CleanupStack::PopAndDestroy( &iaps );

   394                 

   395                 if ( gprs )

   396                     {

   397                     iCchUIHandler->CheckGprsFirstUsageL();

   398                     }

   399                 }

   400             }

   401         

   402         //unload useless plugins    

   403         if( ECCHDisabled == aState )

   404             {

   405             StartPluginUnloadTimer( );

   406             }

   407         //start fast recovery if not started

   408         else if( IsRecoveryNeeded( aState, aError ) )

   409             {

   410             CCHLOGSTRING( "CCCHServiceHandler::StateChangedL network lost, starting recovery" );

   411             iServicesInRecovery.Append( TServiceSelection( aServiceId, aType ) );

   412             StartConnectionRecoveryTimer( CCCHServiceHandler::ConnectionRecoveryEvent );                

   413             }

   414         //stop fast recovery

   415         if( ECCHConnecting != aState && 

   416                 KErrNone == aError &&

   417                 0 < iServicesInRecovery.Count() )

   418             {

   419             CCHLOGSTRING( "CCCHServiceHandler::StateChangedL checking if recovery is still needed" );

   420             TInt idx = iServicesInRecovery.Find( TServiceSelection( aServiceId, aType ) );

   421             if( KErrNotFound != idx )

   422                 {

   423                 CCHLOGSTRING( "CCCHServiceHandler::StateChangedL this service has recovered, recovery still on..." );

   424                 iServicesInRecovery.Remove( idx );

   425                 }

   426             if( 0 == iServicesInRecovery.Count() )

   427                 {

   428                 CCHLOGSTRING( "CCCHServiceHandler::StateChangedL all services recovered, stopping recovery" );

   429                 CancelConnectionRecoveryTimer();

   430                 }

   431             }

   432         

   433         if ( ECCHConnecting != aState || 

   434             ECCHConnecting == aState && KErrNone != aError )

   435             {

   436             // reset startup counter

   437             TBool startupFlag( EFalse );

   438             iServer.SPSHandler().LoadAtStartUpL( aServiceId, aType, startupFlag );

   439             if ( startupFlag )

   440                 {

   441                 iServer.ResetStartupCounterL();

   442                 }

   443             }

   444         }

   445     else

   446         {

   447         User::Leave( index );

   448         }

   449     CCHLOGSTRING( "CCCHServiceHandler::StateChanged: OUT" );

   450         

   451     }

   452 

   453 // -----------------------------------------------------------------------------

   454 // CCCHServiceHandler::StartConnectionRecoveryTimer

   455 // -----------------------------------------------------------------------------

   456 //

   457 void CCCHServiceHandler::StartConnectionRecoveryTimer( TInt (*aFunction)(TAny* aPtr) )

   458     {

   459     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::StartConnectionRecoveryTimer; IN", this );

   460     CancelConnectionRecoveryTimer();

   461     if( !iConnectionRecoveryTimer->IsActive() )

   462         {

   463         iConnectionRecoveryTry = 0;

   464         iConnectionRecoveryTimer->Start( iRecoveryInterval[ iConnectionRecoveryTry ] , 

   465                               0, 

   466                               TCallBack( aFunction, this ) );

   467         CCHLOGSTRING( "CCCHServiceHandler::StartConnectionRecoveryTimer; recovery timer started");

   468         

   469         }

   470     CCHLOGSTRING( "CCCHServiceHandler::StartConnectionRecoveryTimer; OUT");

   471     }

   472 

   473 // -----------------------------------------------------------------------------

   474 // CCCHServiceHandler::CancelConnectionRecoveryTimer

   475 // -----------------------------------------------------------------------------

   476 //

   477 void CCCHServiceHandler::CancelConnectionRecoveryTimer()

   478     {

   479     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::CancelConnectionRecoveryTimer; IN", this );

   480 

   481     if( iConnectionRecoveryTimer->IsActive() )

   482         {

   483         iConnectionRecoveryTimer->Cancel();

   484         }

   485     CCHLOGSTRING( "CCCHServiceHandler::CancelConnectionRecoveryTimer; OUT" );        

   486     }

   487 

   488 // -----------------------------------------------------------------------------

   489 // CCCHServiceHandler::ConnectionRecoveryEvent

   490 // -----------------------------------------------------------------------------

   491 //

   492 TInt CCCHServiceHandler::ConnectionRecoveryEvent( TAny* aSelf )

   493     {

   494     CCHLOGSTRING( "CCCHServiceHandler::ConnectionRecoveryEvent; IN" );

   495     CCCHServiceHandler* self = static_cast<CCCHServiceHandler*>( aSelf );

   496     self->HandleConnectionRecovery();

   497     CCHLOGSTRING( "CCCHServiceHandler::ConnectionRecoveryEvent; OUT" );

   498     return 0;

   499     }

   500 

   501 // -----------------------------------------------------------------------------

   502 // CCCHServiceHandler::HandleConnectionRecovery

   503 // -----------------------------------------------------------------------------

   504 //

   505 void CCCHServiceHandler::HandleConnectionRecovery()

   506     {

   507     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::HandleConnectionRecovery IN",

   508                    this );

   509     iConnectionRecoveryTry++;

   510     CCHLOGSTRING2( "CCCHServiceHandler::HandleConnectionRecovery; recovery try:%d",iConnectionRecoveryTry );

   511     iServer.ConnMonHandler().ScanNetworks( ETrue );    

   512     CancelConnectionRecoveryTimer();

   513     

   514     if( KConnectionRecoveryMaxTries > iConnectionRecoveryTry )

   515         {

   516         CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery; recovery continues" );

   517         iConnectionRecoveryTimer->Start( iRecoveryInterval[ iConnectionRecoveryTry ], 

   518                               0,

   519                               TCallBack( CCCHServiceHandler::ConnectionRecoveryEvent, this ) );

   520         }

   521     else

   522         {

   523         CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery; max tries reached, recovery canceled" );

   524         }                   

   525     CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery OUT" );

   526     }

   527 

   528 // -----------------------------------------------------------------------------

   529 // CCCHServiceHandler::StartPluginUnloadTimer

   530 // -----------------------------------------------------------------------------

   531 //

   532 void CCCHServiceHandler::StartPluginUnloadTimer( )

   533     {

   534     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::StartPluginUnloadTimer; IN", this );

   535     CancelPluginUnloadTimer();

   536     if( !iPluginUnloadTimer->IsActive() )

   537         {

   538         iPluginUnloadTimer->Start( KCCHPluginUnloadTimeout , 

   539                               0, 

   540                               TCallBack( CCCHServiceHandler::PluginUnloadEvent, this ) );

   541         CCHLOGSTRING( "CCCHServiceHandler::StartPluginUnloadTimer; plugin unload timer started");

   542         

   543         }

   544     CCHLOGSTRING( "CCCHServiceHandler::StartPluginUnloadTimer; OUT");

   545     }

   546 

   547 // -----------------------------------------------------------------------------

   548 // CCCHServiceHandler::CancelPluginUnloadTimer

   549 // -----------------------------------------------------------------------------

   550 //

   551 void CCCHServiceHandler::CancelPluginUnloadTimer()

   552     {

   553     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::CancelPluginUnloadTimer; IN", this );

   554 

   555     if( iPluginUnloadTimer->IsActive() )

   556         {

   557         iPluginUnloadTimer->Cancel();

   558         }

   559     CCHLOGSTRING( "CCCHServiceHandler::CancelPluginUnloadTimer; OUT" );        

   560     }

   561 

   562 // -----------------------------------------------------------------------------

   563 // CCCHServiceHandler::StartHandleNotifyDelayTimer

   564 // -----------------------------------------------------------------------------

   565 //

   566 void CCCHServiceHandler::StartHandleNotifyDelayTimer( )

   567     {

   568     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::StartHandleNotifyDelayTimer; IN", this );

   569     

   570     CancelHandleNotifyDelayTimer();

   571     if( !iHandleNotifyDelayTimer->IsActive() )

   572         {

   573         iHandleNotifyDelayTimer->Start( 

   574             KCCHHandleNotifyDelay , 

   575             0, 

   576             TCallBack( CCCHServiceHandler::HandleNotifyEvent, this ) );

   577         

   578         CCHLOGSTRING( "CCCHServiceHandler::StartHandleNotifyDelayTimer; timer started");

   579         }

   580     

   581     CCHLOGSTRING( "CCCHServiceHandler::StartHandleNotifyDelayTimer; OUT" );   

   582     }

   583 

   584 // -----------------------------------------------------------------------------

   585 // CCCHServiceHandler::CancelHandleNotifyDelayTimer

   586 // -----------------------------------------------------------------------------

   587 //

   588 void CCCHServiceHandler::CancelHandleNotifyDelayTimer()

   589     {

   590     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::CancelHandleNotifyDelayTimer; IN", this );

   591 

   592     if( iHandleNotifyDelayTimer->IsActive() )

   593         {

   594         iHandleNotifyDelayTimer->Cancel();

   595         }

   596     

   597     CCHLOGSTRING( "CCCHServiceHandler::CancelHandleNotifyDelayTimer; OUT" );        

   598     }

   599 

   600 // -----------------------------------------------------------------------------

   601 // CCCHServiceHandler::PluginUnloadEvent

   602 // -----------------------------------------------------------------------------

   603 //

   604 TInt CCCHServiceHandler::PluginUnloadEvent( TAny* aSelf )

   605     {

   606     CCHLOGSTRING( "CCCHServiceHandler::PluginUnloadEvent; IN" );

   607     CCCHServiceHandler* self = static_cast<CCCHServiceHandler*>( aSelf );

   608     self->HandlePluginUnload();

   609     CCHLOGSTRING( "CCCHServiceHandler::PluginUnloadEvent; OUT" );

   610     return 0;

   611     }

   612 

   613 // -----------------------------------------------------------------------------

   614 // CCCHServiceHandler::HandleNotifyEvent

   615 // -----------------------------------------------------------------------------

   616 //

   617 TInt CCCHServiceHandler::HandleNotifyEvent( TAny* aSelf )

   618     {

   619     CCHLOGSTRING( "CCCHServiceHandler::HandleNotifyEvent; IN" );

   620   

   621     CCHLOGSTRING( "CCCHServiceHandler::PluginUnloadEvent; IN" );

   622     CCCHServiceHandler* self = static_cast<CCCHServiceHandler*>( aSelf );

   623     self->HandleDelayedNotifyEvent();

   624     CCHLOGSTRING( "CCCHServiceHandler::HandleNotifyEvent; OUT" );

   625     return 0;

   626     }

   627 

   628 // -----------------------------------------------------------------------------

   629 // CCCHServiceHandler::HandlePluginUnload

   630 // -----------------------------------------------------------------------------

   631 //

   632 void CCCHServiceHandler::HandlePluginUnload()

   633     {

   634     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::HandlePluginUnload IN",

   635                    this );

   636     CancelPluginUnloadTimer();

   637     TRAP_IGNORE( UnloadDisabledPluginsL( ) );

   638     

   639     CCHLOGSTRING( "CCCHServiceHandler::HandlePluginUnload OUT" );

   640     }

   641 

   642 // -----------------------------------------------------------------------------

   643 // CCCHServiceHandler::HandleDelayedNotifyEvent

   644 // -----------------------------------------------------------------------------

   645 //

   646 void CCCHServiceHandler::HandleDelayedNotifyEvent()

   647     {

   648     CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::HandleDelayedNotifyEvent IN",

   649                    this );

   650     

   651     CancelHandleNotifyDelayTimer();

   652     

   653     TServiceSelection selection;

   654     selection.iServiceId = iDelayedHandleNotifyServiceId;

   655     TInt index( ServiceExist( selection ) );

   656 

   657     TRAPD( err, 

   658         {

   659         if ( KErrNotFound != index )

   660             {

   661             iServices[ index ]->UpdateL( ETrue );

   662             }

   663         else

   664             {

   665             TCCHService service;

   666             iServer.SPSHandler().GetServiceInfoL( 

   667                 iDelayedHandleNotifyServiceId, service );

   668             AddServiceL( service );

   669             } 

   670         } );

   671 

   672     //Check if service is already marked as enabled, and enable it

   673     if ( KErrNone == err )

   674         {

   675         index = ServiceExist( selection );

   676         if ( KErrNotFound != index )

   677             {

   678             if( iServices[ index ]->StartupFlagSet() && 

   679                 ECCHEnabled != iServices[ index ]->GetState() )

   680                 {

   681                 iCancelNotify = EFalse;

   682                 EnableService( selection, EFalse );

   683                 iCancelNotify = ETrue;

   684                 }

   685             }

   686         }

   687         

   688      // If service has removed, err must be other than none 

   689      // and we have to update all services

   690     if ( KErrNone != err )

   691         {

   692         TRAP_IGNORE( UpdateL( ETrue ) );

   693         }

   694                 

   695     iDelayedHandleNotifyServiceId = 0;

   696     CCHLOGSTRING( "CCCHServiceHandler::HandleDelayedNotifyEvent OUT" );

   697     }

   698 

   699 // ---------------------------------------------------------------------------

   700 // CCCHServiceHandler::Exists

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

   702 // ---------------------------------------------------------------------------

   703 //

   704 TBool CCCHServiceHandler::Exists( TCCHSubserviceType aType, 

   705                                   TCCHSubserviceState aState,

   706                                   TInt aError ) const

   707     {

   708     CCHLOGSTRING3( "CCCHServiceHandler::Exists(%d,%d)",aType,aState );

   709     TBool bReturn( EFalse );

   710     for( TInt i( 0 ); i < iServices.Count(); i++ )

   711         {

   712         for ( TInt j( 0 ); j < iServices[ i ]->SubserviceCount(); j++ )

   713             {

   714             TCCHSubserviceState state = ECCHUninitialized;

   715             TInt err = iServices[ i ]->GetStatus(iServices[ i ]->GetSubserviceType( j ), state );

   716             if( err == KErrNone )

   717                 {

   718                 if( aType == iServices[ i ]->GetSubserviceType( j ) && 

   719                     aState == state &&

   720                     aError == iServices[ i ]->GetError(iServices[ i ]->GetSubserviceType( j ) ) )

   721                     {

   722                     bReturn = ETrue;

   723                     break;

   724                     }

   725                 }

   726             }

   727         }

   728     CCHLOGSTRING2( "CCCHServiceHandler::Exists returns: %d",bReturn );        

   729     return bReturn;

   730     }

   731 

   732 // ---------------------------------------------------------------------------

   733 // CCCHServiceHandler::LoadPluginsL

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

   735 // ---------------------------------------------------------------------------

   736 //

   737 void CCCHServiceHandler::LoadPluginsL()

   738     {

   739     CCHLOGSTRING( "CCCHServiceHandler::LoadPluginsL: IN" );

   740     

   741     // Get plugin uids to array;

   742     RArray<TUid> uids;

   743     CleanupClosePushL( uids );

   744     

   745     TUid pluginUid( KNullUid );

   746         

   747     for( TInt i( 0 ); i < iServices.Count(); i++ )

   748         {     

   749         for ( TInt j( 0 ); j < iServices[ i ]->SubserviceCount(); j++ )

   750             {

   751             if ( iServices[ i ]->StartupFlagSet( j ) )

   752                 {

   753                 pluginUid = iServices[ i ]->GetUidL( j );

   754     

   755                 if ( KErrNotFound == uids.Find( pluginUid ) && 

   756                     KNullUid != pluginUid )

   757                     {

   758                     uids.Append( pluginUid );

   759 

   760                     TRAP_IGNORE( 

   761                         iServer.PluginHandler().LoadPluginsL( pluginUid ) );

   762                     

   763                     // Set notifier to loaded Plug-ins                        

   764                     iServer.PluginHandler().SetServiceNotifier( this );                        

   765                     }

   766                 // Enable subservice

   767                 TServiceSelection selection;

   768                 selection.iServiceId = iServices[ i ]->GetServiceId();

   769                 selection.iType = iServices[ i ]->GetSubserviceType( j );

   770                 EnableService( selection, EFalse );

   771                 }           

   772             }

   773         }        

   774     CleanupStack::PopAndDestroy( &uids );    

   775     

   776     CCHLOGSTRING( "CCCHServiceHandler::LoadPluginsL: OUT" );

   777     }

   778 

   779 // ---------------------------------------------------------------------------

   780 // CCCHServiceHandler::UnloadDisabledPluginsL

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

   782 // ---------------------------------------------------------------------------

   783 //

   784 void CCCHServiceHandler::UnloadDisabledPluginsL( )

   785     {

   786     CCHLOGSTRING( "CCCHServiceHandler::UnloadDisabledPluginsL: IN" );

   787     

   788     // Get plugin uids to array;

   789     RArray<TUid> uidsToBeUnloaded;

   790     RArray<TUid> uidsNotToBeUnloaded;

   791     CleanupClosePushL( uidsToBeUnloaded );

   792     CleanupClosePushL( uidsNotToBeUnloaded );

   793     

   794     

   795     // ...let's go through services & sub services

   796     for ( TInt ixSer=0; ixSer < iServices.Count(); ixSer++ )

   797         {

   798         for ( TInt ixSub=0; ixSub < iServices[ ixSer ]->SubserviceCount(); ixSub++ )

   799             {

   800             TUid pluginUid( KNullUid );

   801             TInt error( KErrNone );

   802             TRAP( error, pluginUid = iServices[ ixSer ]->GetUidL( ixSub ));

   803             // if subservice was found

   804             if( KErrNone == error )

   805                 {

   806                 

   807                 TCCHSubserviceState state = ECCHUninitialized;

   808                 

   809                 // subservice was found, so don't need to check return value

   810                 // coverity[check_return] coverity[unchecked_value]

   811                 iServices[ ixSer ]->GetStatus(

   812                      iServices[ ixSer ]->GetSubserviceType( ixSub ), state );

   813                      

   814                 // if non disabled subservice found, add it to non-unload arry                     

   815                 if( ECCHDisabled != state )

   816                     {

   817                     uidsNotToBeUnloaded.Append( pluginUid );

   818                     }

   819                     

   820                 else

   821                     {

   822                     if( KErrNotFound == uidsToBeUnloaded.Find( pluginUid ) )

   823                         {

   824                         // the others go to unload array

   825                         uidsToBeUnloaded.Append( pluginUid );        

   826                         }

   827                     }

   828                 }

   829             }

   830         }

   831     iServer.PluginHandler().RemoveServiceNotifier( this );

   832     for( TInt i=0; i<uidsToBeUnloaded.Count(); i++ )

   833         {

   834         //unload plugin & set state if not found from non-unloadable array

   835         if( KErrNotFound == uidsNotToBeUnloaded.Find( uidsToBeUnloaded[i] ) )

   836             {

   837             CCHLOGSTRING2(

   838                 "CCCHServiceHandler::UnloadDisabledPluginsL; unloading plugin UID:0x%x",

   839                     uidsToBeUnloaded[i] );

   840             iServer.PluginHandler().UnloadPlugin( uidsToBeUnloaded[i] );

   841             }

   842         }

   843     iServer.PluginHandler().SetServiceNotifier( this );

   844     CleanupStack::PopAndDestroy( &uidsNotToBeUnloaded );   

   845     CleanupStack::PopAndDestroy( &uidsToBeUnloaded );    

   846     CCHLOGSTRING( "CCCHServiceHandler::UnloadDisabledPluginsL: OUT" );

   847     }

   848 

   849 // ---------------------------------------------------------------------------

   850 // CCCHServiceHandler::EnableService

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

   852 // ---------------------------------------------------------------------------

   853 //

   854 TInt CCCHServiceHandler::EnableService( 

   855     const TServiceSelection aServiceSelection, 

   856     const TBool aConnectivityCheck )

   857     {

   858     CCHLOGSTRING( "CCCHServiceHandler::EnableService: IN" );

   859     TInt error( ServiceExist( aServiceSelection ) );

   860     TBool connectionOk( EFalse );

   861     if ( KErrNotFound != error )

   862         {

   863         TInt index = error;

   864         TRAP( error, connectionOk = IsServiceConnectivityDefinedL( aServiceSelection ) );

   865         if( KErrNone == error )

   866             {

   867             if( connectionOk )

   868                 {

   869                 // Start monitoring connectivity changes

   870                 iServer.ConnMonHandler().StartMonitoringConnectionChanges();

   871                 

   872                 if( iCancelNotify )

   873                     {

   874                     DisableNotifyChange();

   875                     }

   876          

   877                 CCHLOGSTRING3( "CCCHServiceHandler::EnableService: service:%d, type:%d",

   878                         aServiceSelection.iServiceId, aServiceSelection.iType );

   879     

   880                 // If client wants to enable VoIP subservice and VoIP are not supported

   881                 // send KErrNotSupported notify to the client

   882                 if ( ( ECCHUnknown == aServiceSelection.iType ||

   883                        ECCHVoIPSub == aServiceSelection.iType ) &&

   884                        iServices[ index ]->SubserviceExist( ECCHVoIPSub ) &&

   885                        !iServer.FeatureManager().VoIPSupported() )

   886                     {

   887                     CCHLOGSTRING( "CCCHServiceHandler::EnableService: No support for VoIP" );

   888                     TRAP_IGNORE( iServices[ index ]->SetErrorL( ECCHVoIPSub, KErrNotSupported ) );

   889                     TRAP_IGNORE( iServices[ index ]->SetStateL( ECCHVoIPSub, ECCHDisabled ) );

   890                     // Enable one by one all subservices except VoIP

   891                     if ( ECCHUnknown == aServiceSelection.iType )

   892                         {

   893                         for ( TInt i( 0 ); i < iServices[ index ]->SubserviceCount(); i++ )

   894                             {

   895                             if ( ECCHVoIPSub != iServices[ index ]->GetSubserviceType( i ) )

   896                                 {

   897                                 TRAP( error, iServices[ index ]->EnableL(

   898                                     iServices[ index ]->GetSubserviceType( i ),

   899                                         aConnectivityCheck, this ) );

   900                                 }

   901                             }

   902                         }

   903                     }

   904                 else

   905                     {

   906                     TRAP( error, iServices[ index ]->EnableL( 

   907                         aServiceSelection.iType, aConnectivityCheck, this ) );

   908                     }

   909                 if( iCancelNotify )

   910                     {

   911                     EnableNotifyChange();

   912                     }

   913                 if( HasWlanIap( aServiceSelection ) && KErrNone == error )

   914                     {

   915                     CCHLOGSTRING( "CCCHServiceHandler::EnableService: Launching WLAN scan..." );

   916                     TRAP_IGNORE( iWlanExtension->EnableWlanScanL() );

   917                     }

   918                 if ( error )

   919                     {

   920                     RArray<TUint> iaps;

   921                     iServer.ConnMonHandler().StopMonitoringConnectionChanges( iaps );

   922                     iaps.Close();

   923                     }

   924                 // There could be new Plug-ins after EnableL, so we must set 

   925                 // notifier to loaded Plug-ins

   926                 iServer.PluginHandler().SetServiceNotifier( this );

   927                 }

   928             else

   929                 {

   930                 error = KCCHErrorAccessPointNotDefined;

   931                 }

   932             CCHLOGSTRING2

   933                     ( "CCCHServiceHandler::EnableService: error: %d", error );

   934             }

   935         }

   936     CCHLOGSTRING( "CCCHServiceHandler::EnableService: OUT" );

   937     return error;

   938     }

   939 

   940 // ---------------------------------------------------------------------------

   941 // CCCHServiceHandler::DisableService

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

   943 // ---------------------------------------------------------------------------

   944 //

   945 TInt CCCHServiceHandler::DisableService( 

   946     const TServiceSelection aServiceSelection )

   947     {

   948     CCHLOGSTRING( "CCCHServiceHandler::DisableService: IN" );

   949     TInt error( ServiceExist( aServiceSelection ) );

   950     

   951     if ( KErrNotFound != error )

   952         {

   953         TInt index( error );

   954         if( iCancelNotify )

   955             {

   956             DisableNotifyChange();

   957             }

   958 

   959         TRAP( error, iServices[ index ]->DisableL(

   960             aServiceSelection.iType ) );

   961         

   962         DisableWlanScan();

   963         if( iCancelNotify )

   964             {

   965             EnableNotifyChange();            

   966             }

   967             CCHLOGSTRING2

   968                 ( "CCCHServiceHandler::DisableService: error: %d", error );

   969         }

   970     CCHLOGSTRING2(

   971         "CCCHServiceHandler::DisableService: return %d OUT", error );

   972     return error;

   973     }

   974     

   975 // ---------------------------------------------------------------------------

   976 // CCCHServiceHandler::DisableWlanScan

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

   978 // ---------------------------------------------------------------------------

   979 //

   980 void CCCHServiceHandler::DisableWlanScan( )

   981     {

   982     CCHLOGSTRING( "CCCHServiceHandler::DisableWlanScan: IN" );

   983     

   984     TBool disableWlanScan( ETrue );

   985     TCCHSubserviceState serviceState( ECCHUninitialized );

   986     TCCHSubserviceType serviceType( ECCHUnknown );

   987     TInt serviceId( 0 );

   988     

   989      // ...let's go through services & sub services

   990     for ( TInt ixSer = 0; ixSer < iServices.Count(); ixSer++ )

   991         {

   992         for ( TInt ixSub = 0; ixSub < iServices[ ixSer ]->SubserviceCount(); ixSub++ )

   993             {

   994             serviceType = iServices[ ixSer ]->GetSubserviceType( ixSub );

   995             TInt err = iServices[ ixSer ]->GetStatus( serviceType, serviceState );

   996             if( err == KErrNone )

   997                 {

   998                 // if found even one enabled/connecting service, do not deactivate scan

   999                 if( ECCHEnabled == serviceState || ECCHConnecting == serviceState )

  1000                     {

  1001                     serviceId =  iServices[ ixSer ]->GetServiceId();

  1002                     

  1003                     TServiceConnectionInfo serviceConnInfo( serviceId, serviceType, 0, 0 );

  1004                     GetConnectionInfo( serviceConnInfo );

  1005                     // existing snap overrides iap

  1006                     if( serviceConnInfo.iSNAPId != 0 )

  1007                         {

  1008                         TInt wlanIaps( 0 );

  1009                         TInt allIaps( 0 );

  1010                         TInt error( KErrNone );

  1011                         TRAP( error, 

  1012                             {

  1013                             wlanIaps = iCommDbWatcher->GetIapCountFromSnap( serviceConnInfo.iSNAPId, ETrue, ETrue );

  1014                             allIaps = iCommDbWatcher->GetIapCountFromSnap( serviceConnInfo.iSNAPId, EFalse );

  1015                             } );

  1016                         

  1017                         // in case of possibility -> WLAN ALR we need to keep the scan active

  1018                         // in case of possibility -> do not disable wlan scan if there is only one iap 

  1019                         // and the iap is wlan

  1020                         if( KErrNone == error )

  1021                             {

  1022                             if( 1 <= allIaps && 0 < wlanIaps )

  1023                                 {

  1024                                 disableWlanScan = EFalse;

  1025                                 break;

  1026                                 }

  1027                             }

  1028                         }

  1029                     else if( serviceConnInfo.iIapId != 0 )

  1030                         {

  1031                         TInt error( KErrNone );

  1032                         TBool isWlanIap( EFalse );

  1033                         

  1034                         TRAP( error, isWlanIap = iCommDbWatcher->IsWlanApL( serviceConnInfo.iIapId ) )

  1035                         CCHLOGSTRING2( "CCCHServiceHandler::DisableWlanScan: error: %d", error );

  1036                         

  1037                         if( KErrNone == error)

  1038                             {

  1039                             //in case the iap is wlan type, scan is not deactivated

  1040                             if( isWlanIap )

  1041                                 {

  1042                                 disableWlanScan = EFalse;

  1043                                 break;

  1044                                 }

  1045                             }

  1046                         }

  1047                     }

  1048                 }

  1049             }

  1050         if( !disableWlanScan )

  1051             {

  1052             break;

  1053             }

  1054         }            

  1055     if( disableWlanScan )

  1056         {

  1057         CCHLOGSTRING( "CCCHServiceHandler::DisableWlanScan disabling wlan scan..." );

  1058         

  1059         TRAP_IGNORE( iWlanExtension->DisableWlanScanL() ) ;

  1060         }

  1061     CCHLOGSTRING( "CCCHServiceHandler::DisableWlanScan: OUT" );

  1062     }

  1063     

  1064 // ---------------------------------------------------------------------------

  1065 // CCCHServiceHandler::SetConnectionInfo

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

  1067 // ---------------------------------------------------------------------------

  1068 //

  1069 TInt CCCHServiceHandler::SetConnectionInfo( 

  1070     const TServiceConnectionInfo aServiceConnInfo )

  1071     {

  1072     CCHLOGSTRING( "CCCHServiceHandler::SetConnectionInfo: IN" );

  1073     TInt error( KErrNotFound );

  1074     CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: serviceId %d",

  1075         aServiceConnInfo.iServiceSelection.iServiceId );

  1076     CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: iType %d",

  1077         aServiceConnInfo.iServiceSelection.iType );

  1078     CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: iSNAPId %d",

  1079         aServiceConnInfo.iSNAPId );

  1080     CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: iIapId %d",

  1081         aServiceConnInfo.iIapId );

  1082     CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: iReserved %d",

  1083         aServiceConnInfo.iReserved );

  1084 

  1085     if ( KErrNotFound != 

  1086         ( error = FindService( aServiceConnInfo.iServiceSelection.iServiceId ) ) )

  1087         {

  1088         TInt index( error );

  1089         TRAP( error, iServices[ index ]->SetConnectionInfoL( 

  1090             aServiceConnInfo ) );

  1091         StartPluginUnloadTimer( );

  1092         CCHLOGSTRING2

  1093             ( "CCCHServiceHandler::SetConnectionInfo: error: %d", error );

  1094         }

  1095     CCHLOGSTRING( "CCCHServiceHandler::SetConnectionInfo: OUT" );

  1096     return error;

  1097     }

  1098     

  1099 // ---------------------------------------------------------------------------

  1100 // CCCHServiceHandler::GetConnectionInfo

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

  1102 // ---------------------------------------------------------------------------

  1103 //

  1104 TInt CCCHServiceHandler::GetConnectionInfo( 

  1105     TServiceConnectionInfo& aServiceConnInfo )

  1106     {

  1107     CCHLOGSTRING( "CCCHServiceHandler::GetConnectionInfo: IN" );

  1108     TInt error( KErrNotFound );

  1109     

  1110     if ( KErrNotFound != 

  1111         ( error = FindService( aServiceConnInfo.ServiceId() ) ) )

  1112         {

  1113         TInt index( error );

  1114         TRAP( error, iServices[ index ]->GetConnectionInfoL( 

  1115                 aServiceConnInfo ) );

  1116         StartPluginUnloadTimer( );

  1117         CCHLOGSTRING2

  1118             ( "CCCHServiceHandler::GetConnectionInfo: error: %d", error );

  1119         }

  1120     CCHLOGSTRING( "CCCHServiceHandler::GetConnectionInfo: OUT" );

  1121     return error;

  1122     }

  1123 

  1124 // ---------------------------------------------------------------------------

  1125 // CCCHServiceHandler::UsesWlanIapL

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

  1127 // ---------------------------------------------------------------------------

  1128 //

  1129 TBool CCCHServiceHandler::UsesWlanIap( 

  1130     const TServiceSelection& aServiceSelection )

  1131     {

  1132     CCHLOGSTRING( "CCCHServiceHandler::UsesWlanIap: IN" );

  1133     TBool isWlanIap( EFalse );

  1134     TServiceConnectionInfo serviceConnInfo(

  1135             aServiceSelection.iServiceId, aServiceSelection.iType, 0, 0 );