diff -r f742655b05bf -r d38647835c2e convergedconnectionhandler/cchserver/src/cchservicehandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/convergedconnectionhandler/cchserver/src/cchservicehandler.cpp Wed Sep 01 12:29:57 2010 +0100 @@ -0,0 +1,1880 @@ +/* +* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: CCCHServiceHandler implementation +* +*/ + + +// INCLUDE FILES +#include +#include + +#include "cchservicehandler.h" +#include "cchserverbase.h" +#include "cchspshandler.h" +#include "cchlogger.h" +#include "cchpluginhandler.h" +#include "cchuihandler.h" +#include "cchconnmonhandler.h" +#include "cchwlanextension.h" +#include "cchcommdbwatcher.h" +#include "cchcommdbwatcherobserver.h" + +// EXTERNAL DATA STRUCTURES +// None + +// EXTERNAL FUNCTION PROTOTYPES +// None + +// CONSTANTS + +const TInt KConnectionRecoveryMaxTries = 5; + +const TInt KCCHFirstRecovery = 15000000; +const TInt KCCHSecondRecovery = 15000000; +const TInt KCCHThirdRecovery = 30000000; +const TInt KCCHFourthRecovery = 60000000; +const TInt KCCHFifthRecovery = 60000000; + +const TInt KCCHPluginUnloadTimeout = 5000000; + +const TInt KCCHHandleNotifyDelay = 1000000; + +// MACROS +// None + +// LOCAL CONSTANTS AND MACROS +// None + +// MODULE DATA STRUCTURES +// None + +// LOCAL FUNCTION PROTOTYPES +// None + +// FORWARD DECLARATIONS +// None. + +// ============================= LOCAL FUNCTIONS ============================= + +// ============================ MEMBER FUNCTIONS ============================= + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::CCCHServiceHandler +// C++ default constructor can NOT contain any code, that might leave. +// --------------------------------------------------------------------------- +// +CCCHServiceHandler::CCCHServiceHandler( CCCHServerBase& aServer ) : + iServer( aServer ), + iConnectionRecoveryTry( 0 ), + iCancelNotify( ETrue ) + { + // No implementation required + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::ConstructL +// Symbian 2nd phase constructor can leave. +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::ConstructL() + { + iNotifier = CSPNotifyChange::NewL( *this ); + iCchUIHandler = CCchUIHandler::NewL( iServer, *this ); + iConnectionRecoveryTimer = CPeriodic::NewL( CPeriodic::EPriorityStandard ); + iCommDbWatcher = CCCHCommDbWatcher::NewL( *this ); + iPluginUnloadTimer = CPeriodic::NewL( CPeriodic::EPriorityStandard ); + iHandleNotifyDelayTimer = CPeriodic::NewL( CPeriodic::EPriorityStandard ); + iRecoveryInterval.Append( KCCHFirstRecovery ); + iRecoveryInterval.Append( KCCHSecondRecovery ); + iRecoveryInterval.Append( KCCHThirdRecovery ); + iRecoveryInterval.Append( KCCHFourthRecovery ); + iRecoveryInterval.Append( KCCHFifthRecovery ); + iWlanExtension = CCchWlanExtension::NewL( ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::NewL +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CCCHServiceHandler* CCCHServiceHandler::NewL( CCCHServerBase& aServer ) + { + CCCHServiceHandler* self = CCCHServiceHandler::NewLC( aServer ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::NewLC +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CCCHServiceHandler* CCCHServiceHandler::NewLC( CCCHServerBase& aServer ) + { + CCCHServiceHandler* self = new (ELeave) CCCHServiceHandler( aServer ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// Destructor +CCCHServiceHandler::~CCCHServiceHandler() + { + if ( iCchUIHandler ) + { + iCchUIHandler->Destroy(); + } + + delete iWlanExtension; + delete iConnectionRecoveryTimer; + delete iPluginUnloadTimer; + delete iHandleNotifyDelayTimer; + delete iCommDbWatcher; + + if( iNotifier ) + { + iNotifier->Cancel(); + delete iNotifier; + iNotifier = NULL; + } + + iServiceIds.Close(); + iServer.PluginHandler().RemoveServiceNotifier( this ); + iServices.ResetAndDestroy(); + iServicesInRecovery.Close(); + iRecoveryInterval.Close(); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::InitServiceHandlerL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::InitServiceHandlerL() + { + CCHLOGSTRING2( "CCCHServiceHandler::InitServiceHandlerL [0x%x]: IN",this ); + + RArray serviceIds; + CleanupClosePushL( serviceIds ); + iServer.SPSHandler().GetServiceIdsL( serviceIds ); + for ( TInt i( 0 ); i < serviceIds.Count(); i++ ) + { + if ( KErrNotFound == FindService( serviceIds[ i ] ) ) + { + TCCHService service; + TRAPD( error, iServer.SPSHandler().GetServiceInfoL( + serviceIds[ i ], service ) ); + if ( KErrNone == error ) + { + AddServiceL( service ); + } + } + } + CleanupStack::PopAndDestroy( &serviceIds ); + // Subscribe to service change notifies + EnableNotifyChange(); + + CCHLOGSTRING( "CCCHServiceHandler::InitServiceHandlerL: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::AddServiceL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::AddServiceL( TCCHService& aService ) + { + CCHLOGSTRING( "CCCHServiceHandler::AddServiceL: IN" ); + + CCCHServiceInfo* cchServiceInfo = CCCHServiceInfo::NewLC( iServer ); + cchServiceInfo->SetServiceId( aService.iServiceId ); + cchServiceInfo->SetName( aService.iServiceName ); + CCHLOGSTRING2( "CCCHServiceHandler::AddServiceL: adding service with %d subservices",aService.iSubservices.Count() ); + for ( TInt i( 0 ); i < aService.iSubservices.Count(); i++ ) + { + cchServiceInfo->AddSubserviceL( aService.iSubservices[ i ] ); + } + + CleanupStack::Pop( cchServiceInfo ); + iServices.Append( cchServiceInfo ); + + CCHLOGSTRING( "CCCHServiceHandler::AddServiceL: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::UpdateL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::UpdateL( TBool aReadSettingTable ) + { + CCHLOGSTRING( "CCCHServiceHandler::UpdateL: IN" ); + + // Read settings from service table + if ( aReadSettingTable ) + { + RArray serviceIds; + CleanupClosePushL( serviceIds ); + + TInt index( KErrNotFound ); + iServer.SPSHandler().GetServiceIdsL( serviceIds ); + + for ( TInt i( 0 ); i < serviceIds.Count(); i++ ) + { + index = FindService( serviceIds[ i ] ); + if ( KErrNotFound != index ) + { + iServices[ index ]->UpdateL( ETrue ); + } + else + { + CCHLOGSTRING2 + ( "CCCHSeviceHandler::UpdateL: \ + New service found: ServiceId %d", serviceIds[ i ] ); + TCCHService service; + TRAPD( error, iServer.SPSHandler().GetServiceInfoL( + serviceIds[ i ], service ) ); + if ( KErrNone == error ) + { + AddServiceL( service ); + } + } + } + if ( serviceIds.Count() < iServices.Count() ) + { + // Remove service's which does not exist anymore + for ( TInt i( 0 ); i < iServices.Count(); i++ ) + { + if ( KErrNotFound == serviceIds.Find( + iServices[ i ]->GetServiceId( ) ) ) + { + CCHLOGSTRING2 + ( "CCCHSeviceHandler::UpdateL: \ + service removed: ServiceId %d", + iServices[ i ]->GetServiceId() ); + delete iServices[ i ]; + iServices.Remove( i ); + i--; + StartPluginUnloadTimer( ); + } + } + } + CleanupStack::PopAndDestroy( &serviceIds ); + } + else + { + for ( TInt i( 0 ); i < iServices.Count(); i++ ) + { + iServices[ i ]->UpdateL(); + } + } + + CCHLOGSTRING( "CCCHServiceHandler::UpdateL: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::IsStartupFlagSet +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHServiceHandler::IsStartupFlagSet() const + { + TBool ret( EFalse ); + + for ( TInt i( 0 ); i < iServices.Count() && !ret; i++ ) + { + ret = iServices[ i ]->StartupFlagSet(); + } + + CCHLOGSTRING2( "CCCHServiceHandler::IsStartupFlagSet: %d", ret ); + return ret; + } + + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::IsRecoveryNeeded +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHServiceHandler::IsRecoveryNeeded( + const TCCHSubserviceState aState, + TInt aError ) + { + TBool recover( EFalse ); + CCHLOGSTRING( "CCCHServiceHandler::IsRecoveryNeeded: IN" ); + if( !iServer.FeatureManager().OfflineMode() && + ECCHConnecting == aState && ( + KCCHErrorNetworkLost == aError || + KCCHErrorServiceNotResponding == aError ) && + !iConnectionRecoveryTimer->IsActive() ) + { + recover = ETrue; + } + CCHLOGSTRING2( "CCCHServiceHandler::IsRecoveryNeeded: OUT, value=%d", recover ); + return recover; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::StateChangedL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::StateChangedL( const TUint aServiceId, + const TCCHSubserviceType aType, + const TCCHSubserviceState aState, + const TInt aError ) + { + + CCHLOGSTRING( "CCCHServiceHandler::StateChanged: IN" ); + CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service id; %d",aServiceId ); + CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service type; %d",aType ); + CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service new state; %d",aState ); + CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service error; %d",aError ); + TInt index( FindService( aServiceId ) ); + if ( KErrNotFound != index ) + { + iServices[ index ]->SetErrorL( aType, aError ); + iServices[ index ]->SetStateL( aType, aState ); + //toggle voip indicator & emergency note if needed + if( ECCHVoIPSub == aType ) + { + iCchUIHandler->UpdateUI( ); + } + + if ( ECCHEnabled == aState && !iCchUIHandler->IsCostWarningSeen() ) + { + // Check for possible first usage of GPRS (roaming cost warning) + TServiceConnectionInfo serviceConnInfo( aServiceId, aType, 0, 0 ); + GetConnectionInfo( serviceConnInfo ); + + if ( serviceConnInfo.iIapId ) + { + // Stop monitoring connectivity changes and take new connections + RArray iaps; + CleanupClosePushL( iaps ); + TBool gprs( EFalse ); + iServer.ConnMonHandler().StopMonitoringConnectionChanges( iaps ); + + // Are we connected via VPN + if ( iCommDbWatcher->IsVpnApL( serviceConnInfo.iIapId ) ) + { + // Remove iaps whom are not linked to vpn(snap or iap) + TRAP_IGNORE( iCommDbWatcher->RemoveOtherThanVpnIapsL( + iaps, serviceConnInfo.iIapId ) ); + + for ( TInt i( 0 ); i < iaps.Count(); i++ ) + { + CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: new connections: %d",iaps[ i ] ); + + // if any new connection is gprs connection show note if not showed already + if( !iCommDbWatcher->IsVpnApL( iaps[ i ] ) && !iCommDbWatcher->IsWlanApL( iaps[ i ] ) ) + { + gprs = ETrue; + break; + } + } + } + else if( !iCommDbWatcher->IsWlanApL( serviceConnInfo.iIapId ) ) + { + gprs = ETrue; + } + CleanupStack::PopAndDestroy( &iaps ); + + if ( gprs ) + { + iCchUIHandler->CheckGprsFirstUsageL(); + } + } + } + + //unload useless plugins + if( ECCHDisabled == aState ) + { + StartPluginUnloadTimer( ); + } + //start fast recovery if not started + else if( IsRecoveryNeeded( aState, aError ) ) + { + CCHLOGSTRING( "CCCHServiceHandler::StateChangedL network lost, starting recovery" ); + iServicesInRecovery.Append( TServiceSelection( aServiceId, aType ) ); + StartConnectionRecoveryTimer( CCCHServiceHandler::ConnectionRecoveryEvent ); + } + //stop fast recovery + if( ECCHConnecting != aState && + KErrNone == aError && + 0 < iServicesInRecovery.Count() ) + { + CCHLOGSTRING( "CCCHServiceHandler::StateChangedL checking if recovery is still needed" ); + TInt idx = iServicesInRecovery.Find( TServiceSelection( aServiceId, aType ) ); + if( KErrNotFound != idx ) + { + CCHLOGSTRING( "CCCHServiceHandler::StateChangedL this service has recovered, recovery still on..." ); + iServicesInRecovery.Remove( idx ); + } + if( 0 == iServicesInRecovery.Count() ) + { + CCHLOGSTRING( "CCCHServiceHandler::StateChangedL all services recovered, stopping recovery" ); + CancelConnectionRecoveryTimer(); + } + } + + if ( ECCHConnecting != aState || + ECCHConnecting == aState && KErrNone != aError ) + { + // reset startup counter + TBool startupFlag( EFalse ); + iServer.SPSHandler().LoadAtStartUpL( aServiceId, aType, startupFlag ); + if ( startupFlag ) + { + iServer.ResetStartupCounterL(); + } + } + } + else + { + User::Leave( index ); + } + CCHLOGSTRING( "CCCHServiceHandler::StateChanged: OUT" ); + + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::StartConnectionRecoveryTimer +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::StartConnectionRecoveryTimer( TInt (*aFunction)(TAny* aPtr) ) + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::StartConnectionRecoveryTimer; IN", this ); + CancelConnectionRecoveryTimer(); + if( !iConnectionRecoveryTimer->IsActive() ) + { + iConnectionRecoveryTry = 0; + iConnectionRecoveryTimer->Start( iRecoveryInterval[ iConnectionRecoveryTry ] , + 0, + TCallBack( aFunction, this ) ); + CCHLOGSTRING( "CCCHServiceHandler::StartConnectionRecoveryTimer; recovery timer started"); + + } + CCHLOGSTRING( "CCCHServiceHandler::StartConnectionRecoveryTimer; OUT"); + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::CancelConnectionRecoveryTimer +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::CancelConnectionRecoveryTimer() + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::CancelConnectionRecoveryTimer; IN", this ); + + if( iConnectionRecoveryTimer->IsActive() ) + { + iConnectionRecoveryTimer->Cancel(); + } + CCHLOGSTRING( "CCCHServiceHandler::CancelConnectionRecoveryTimer; OUT" ); + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::ConnectionRecoveryEvent +// ----------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::ConnectionRecoveryEvent( TAny* aSelf ) + { + CCHLOGSTRING( "CCCHServiceHandler::ConnectionRecoveryEvent; IN" ); + CCCHServiceHandler* self = static_cast( aSelf ); + self->HandleConnectionRecovery(); + CCHLOGSTRING( "CCCHServiceHandler::ConnectionRecoveryEvent; OUT" ); + return 0; + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::HandleConnectionRecovery +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::HandleConnectionRecovery() + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::HandleConnectionRecovery IN", + this ); + iConnectionRecoveryTry++; + CCHLOGSTRING2( "CCCHServiceHandler::HandleConnectionRecovery; recovery try:%d",iConnectionRecoveryTry ); + iServer.ConnMonHandler().ScanNetworks( ETrue ); + CancelConnectionRecoveryTimer(); + + if( KConnectionRecoveryMaxTries > iConnectionRecoveryTry ) + { + CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery; recovery continues" ); + iConnectionRecoveryTimer->Start( iRecoveryInterval[ iConnectionRecoveryTry ], + 0, + TCallBack( CCCHServiceHandler::ConnectionRecoveryEvent, this ) ); + } + else + { + CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery; max tries reached, recovery canceled" ); + } + CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery OUT" ); + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::StartPluginUnloadTimer +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::StartPluginUnloadTimer( ) + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::StartPluginUnloadTimer; IN", this ); + CancelPluginUnloadTimer(); + if( !iPluginUnloadTimer->IsActive() ) + { + iPluginUnloadTimer->Start( KCCHPluginUnloadTimeout , + 0, + TCallBack( CCCHServiceHandler::PluginUnloadEvent, this ) ); + CCHLOGSTRING( "CCCHServiceHandler::StartPluginUnloadTimer; plugin unload timer started"); + + } + CCHLOGSTRING( "CCCHServiceHandler::StartPluginUnloadTimer; OUT"); + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::CancelPluginUnloadTimer +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::CancelPluginUnloadTimer() + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::CancelPluginUnloadTimer; IN", this ); + + if( iPluginUnloadTimer->IsActive() ) + { + iPluginUnloadTimer->Cancel(); + } + CCHLOGSTRING( "CCCHServiceHandler::CancelPluginUnloadTimer; OUT" ); + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::StartHandleNotifyDelayTimer +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::StartHandleNotifyDelayTimer( ) + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::StartHandleNotifyDelayTimer; IN", this ); + + CancelHandleNotifyDelayTimer(); + if( !iHandleNotifyDelayTimer->IsActive() ) + { + iHandleNotifyDelayTimer->Start( + KCCHHandleNotifyDelay , + 0, + TCallBack( CCCHServiceHandler::HandleNotifyEvent, this ) ); + + CCHLOGSTRING( "CCCHServiceHandler::StartHandleNotifyDelayTimer; timer started"); + } + + CCHLOGSTRING( "CCCHServiceHandler::StartHandleNotifyDelayTimer; OUT" ); + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::CancelHandleNotifyDelayTimer +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::CancelHandleNotifyDelayTimer() + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::CancelHandleNotifyDelayTimer; IN", this ); + + if( iHandleNotifyDelayTimer->IsActive() ) + { + iHandleNotifyDelayTimer->Cancel(); + } + + CCHLOGSTRING( "CCCHServiceHandler::CancelHandleNotifyDelayTimer; OUT" ); + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::PluginUnloadEvent +// ----------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::PluginUnloadEvent( TAny* aSelf ) + { + CCHLOGSTRING( "CCCHServiceHandler::PluginUnloadEvent; IN" ); + CCCHServiceHandler* self = static_cast( aSelf ); + self->HandlePluginUnload(); + CCHLOGSTRING( "CCCHServiceHandler::PluginUnloadEvent; OUT" ); + return 0; + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::HandleNotifyEvent +// ----------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::HandleNotifyEvent( TAny* aSelf ) + { + CCHLOGSTRING( "CCCHServiceHandler::HandleNotifyEvent; IN" ); + + CCHLOGSTRING( "CCCHServiceHandler::PluginUnloadEvent; IN" ); + CCCHServiceHandler* self = static_cast( aSelf ); + self->HandleDelayedNotifyEvent(); + CCHLOGSTRING( "CCCHServiceHandler::HandleNotifyEvent; OUT" ); + return 0; + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::HandlePluginUnload +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::HandlePluginUnload() + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::HandlePluginUnload IN", + this ); + CancelPluginUnloadTimer(); + TRAP_IGNORE( UnloadDisabledPluginsL( ) ); + + CCHLOGSTRING( "CCCHServiceHandler::HandlePluginUnload OUT" ); + } + +// ----------------------------------------------------------------------------- +// CCCHServiceHandler::HandleDelayedNotifyEvent +// ----------------------------------------------------------------------------- +// +void CCCHServiceHandler::HandleDelayedNotifyEvent() + { + CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::HandleDelayedNotifyEvent IN", + this ); + + CancelHandleNotifyDelayTimer(); + + TServiceSelection selection; + selection.iServiceId = iDelayedHandleNotifyServiceId; + TInt index( ServiceExist( selection ) ); + + TRAPD( err, + { + if ( KErrNotFound != index ) + { + iServices[ index ]->UpdateL( ETrue ); + } + else + { + TCCHService service; + iServer.SPSHandler().GetServiceInfoL( + iDelayedHandleNotifyServiceId, service ); + AddServiceL( service ); + } + } ); + + //Check if service is already marked as enabled, and enable it + if ( KErrNone == err ) + { + index = ServiceExist( selection ); + if ( KErrNotFound != index ) + { + if( iServices[ index ]->StartupFlagSet() && + ECCHEnabled != iServices[ index ]->GetState() ) + { + iCancelNotify = EFalse; + EnableService( selection, EFalse ); + iCancelNotify = ETrue; + } + } + } + + // If service has removed, err must be other than none + // and we have to update all services + if ( KErrNone != err ) + { + TRAP_IGNORE( UpdateL( ETrue ) ); + } + + iDelayedHandleNotifyServiceId = 0; + CCHLOGSTRING( "CCCHServiceHandler::HandleDelayedNotifyEvent OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::Exists +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHServiceHandler::Exists( TCCHSubserviceType aType, + TCCHSubserviceState aState, + TInt aError ) const + { + CCHLOGSTRING3( "CCCHServiceHandler::Exists(%d,%d)",aType,aState ); + TBool bReturn( EFalse ); + for( TInt i( 0 ); i < iServices.Count(); i++ ) + { + for ( TInt j( 0 ); j < iServices[ i ]->SubserviceCount(); j++ ) + { + TCCHSubserviceState state = ECCHUninitialized; + TInt err = iServices[ i ]->GetStatus(iServices[ i ]->GetSubserviceType( j ), state ); + if( err == KErrNone ) + { + if( aType == iServices[ i ]->GetSubserviceType( j ) && + aState == state && + aError == iServices[ i ]->GetError(iServices[ i ]->GetSubserviceType( j ) ) ) + { + bReturn = ETrue; + break; + } + } + } + } + CCHLOGSTRING2( "CCCHServiceHandler::Exists returns: %d",bReturn ); + return bReturn; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::LoadPluginsL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::LoadPluginsL() + { + CCHLOGSTRING( "CCCHServiceHandler::LoadPluginsL: IN" ); + + // Get plugin uids to array; + RArray uids; + CleanupClosePushL( uids ); + + TUid pluginUid( KNullUid ); + + for( TInt i( 0 ); i < iServices.Count(); i++ ) + { + for ( TInt j( 0 ); j < iServices[ i ]->SubserviceCount(); j++ ) + { + if ( iServices[ i ]->StartupFlagSet( j ) ) + { + pluginUid = iServices[ i ]->GetUidL( j ); + + if ( KErrNotFound == uids.Find( pluginUid ) && + KNullUid != pluginUid ) + { + uids.Append( pluginUid ); + + TRAP_IGNORE( + iServer.PluginHandler().LoadPluginsL( pluginUid ) ); + + // Set notifier to loaded Plug-ins + iServer.PluginHandler().SetServiceNotifier( this ); + } + // Enable subservice + TServiceSelection selection; + selection.iServiceId = iServices[ i ]->GetServiceId(); + selection.iType = iServices[ i ]->GetSubserviceType( j ); + EnableService( selection, EFalse ); + } + } + } + CleanupStack::PopAndDestroy( &uids ); + + CCHLOGSTRING( "CCCHServiceHandler::LoadPluginsL: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::UnloadDisabledPluginsL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::UnloadDisabledPluginsL( ) + { + CCHLOGSTRING( "CCCHServiceHandler::UnloadDisabledPluginsL: IN" ); + + // Get plugin uids to array; + RArray uidsToBeUnloaded; + RArray uidsNotToBeUnloaded; + CleanupClosePushL( uidsToBeUnloaded ); + CleanupClosePushL( uidsNotToBeUnloaded ); + + + // ...let's go through services & sub services + for ( TInt ixSer=0; ixSer < iServices.Count(); ixSer++ ) + { + for ( TInt ixSub=0; ixSub < iServices[ ixSer ]->SubserviceCount(); ixSub++ ) + { + TUid pluginUid( KNullUid ); + TInt error( KErrNone ); + TRAP( error, pluginUid = iServices[ ixSer ]->GetUidL( ixSub )); + // if subservice was found + if( KErrNone == error ) + { + + TCCHSubserviceState state = ECCHUninitialized; + + // subservice was found, so don't need to check return value + // coverity[check_return] coverity[unchecked_value] + iServices[ ixSer ]->GetStatus( + iServices[ ixSer ]->GetSubserviceType( ixSub ), state ); + + // if non disabled subservice found, add it to non-unload arry + if( ECCHDisabled != state ) + { + uidsNotToBeUnloaded.Append( pluginUid ); + } + + else + { + if( KErrNotFound == uidsToBeUnloaded.Find( pluginUid ) ) + { + // the others go to unload array + uidsToBeUnloaded.Append( pluginUid ); + } + } + } + } + } + iServer.PluginHandler().RemoveServiceNotifier( this ); + for( TInt i=0; iSubserviceExist( ECCHVoIPSub ) && + !iServer.FeatureManager().VoIPSupported() ) + { + CCHLOGSTRING( "CCCHServiceHandler::EnableService: No support for VoIP" ); + TRAP_IGNORE( iServices[ index ]->SetErrorL( ECCHVoIPSub, KErrNotSupported ) ); + TRAP_IGNORE( iServices[ index ]->SetStateL( ECCHVoIPSub, ECCHDisabled ) ); + // Enable one by one all subservices except VoIP + if ( ECCHUnknown == aServiceSelection.iType ) + { + for ( TInt i( 0 ); i < iServices[ index ]->SubserviceCount(); i++ ) + { + if ( ECCHVoIPSub != iServices[ index ]->GetSubserviceType( i ) ) + { + TRAP( error, iServices[ index ]->EnableL( + iServices[ index ]->GetSubserviceType( i ), + aConnectivityCheck, this ) ); + } + } + } + } + else + { + TRAP( error, iServices[ index ]->EnableL( + aServiceSelection.iType, aConnectivityCheck, this ) ); + } + if( iCancelNotify ) + { + EnableNotifyChange(); + } + if( HasWlanIap( aServiceSelection ) && KErrNone == error ) + { + CCHLOGSTRING( "CCCHServiceHandler::EnableService: Launching WLAN scan..." ); + TRAP_IGNORE( iWlanExtension->EnableWlanScanL() ); + } + if ( error ) + { + RArray iaps; + iServer.ConnMonHandler().StopMonitoringConnectionChanges( iaps ); + iaps.Close(); + } + // There could be new Plug-ins after EnableL, so we must set + // notifier to loaded Plug-ins + iServer.PluginHandler().SetServiceNotifier( this ); + } + else + { + error = KCCHErrorAccessPointNotDefined; + } + CCHLOGSTRING2 + ( "CCCHServiceHandler::EnableService: error: %d", error ); + } + } + CCHLOGSTRING( "CCCHServiceHandler::EnableService: OUT" ); + return error; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::DisableService +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::DisableService( + const TServiceSelection aServiceSelection ) + { + CCHLOGSTRING( "CCCHServiceHandler::DisableService: IN" ); + TInt error( ServiceExist( aServiceSelection ) ); + + if ( KErrNotFound != error ) + { + TInt index( error ); + if( iCancelNotify ) + { + DisableNotifyChange(); + } + + TRAP( error, iServices[ index ]->DisableL( + aServiceSelection.iType ) ); + + DisableWlanScan(); + if( iCancelNotify ) + { + EnableNotifyChange(); + } + CCHLOGSTRING2 + ( "CCCHServiceHandler::DisableService: error: %d", error ); + } + CCHLOGSTRING2( + "CCCHServiceHandler::DisableService: return %d OUT", error ); + return error; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::DisableWlanScan +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::DisableWlanScan( ) + { + CCHLOGSTRING( "CCCHServiceHandler::DisableWlanScan: IN" ); + + TBool disableWlanScan( ETrue ); + TCCHSubserviceState serviceState( ECCHUninitialized ); + TCCHSubserviceType serviceType( ECCHUnknown ); + TInt serviceId( 0 ); + + // ...let's go through services & sub services + for ( TInt ixSer = 0; ixSer < iServices.Count(); ixSer++ ) + { + for ( TInt ixSub = 0; ixSub < iServices[ ixSer ]->SubserviceCount(); ixSub++ ) + { + serviceType = iServices[ ixSer ]->GetSubserviceType( ixSub ); + TInt err = iServices[ ixSer ]->GetStatus( serviceType, serviceState ); + if( err == KErrNone ) + { + // if found even one enabled/connecting service, do not deactivate scan + if( ECCHEnabled == serviceState || ECCHConnecting == serviceState ) + { + serviceId = iServices[ ixSer ]->GetServiceId(); + + TServiceConnectionInfo serviceConnInfo( serviceId, serviceType, 0, 0 ); + GetConnectionInfo( serviceConnInfo ); + // existing snap overrides iap + if( serviceConnInfo.iSNAPId != 0 ) + { + TInt wlanIaps( 0 ); + TInt allIaps( 0 ); + TInt error( KErrNone ); + TRAP( error, + { + wlanIaps = iCommDbWatcher->GetIapCountFromSnap( serviceConnInfo.iSNAPId, ETrue, ETrue ); + allIaps = iCommDbWatcher->GetIapCountFromSnap( serviceConnInfo.iSNAPId, EFalse ); + } ); + + // in case of possibility -> WLAN ALR we need to keep the scan active + // in case of possibility -> do not disable wlan scan if there is only one iap + // and the iap is wlan + if( KErrNone == error ) + { + if( 1 <= allIaps && 0 < wlanIaps ) + { + disableWlanScan = EFalse; + break; + } + } + } + else if( serviceConnInfo.iIapId != 0 ) + { + TInt error( KErrNone ); + TBool isWlanIap( EFalse ); + + TRAP( error, isWlanIap = iCommDbWatcher->IsWlanApL( serviceConnInfo.iIapId ) ) + CCHLOGSTRING2( "CCCHServiceHandler::DisableWlanScan: error: %d", error ); + + if( KErrNone == error) + { + //in case the iap is wlan type, scan is not deactivated + if( isWlanIap ) + { + disableWlanScan = EFalse; + break; + } + } + } + } + } + } + if( !disableWlanScan ) + { + break; + } + } + if( disableWlanScan ) + { + CCHLOGSTRING( "CCCHServiceHandler::DisableWlanScan disabling wlan scan..." ); + + TRAP_IGNORE( iWlanExtension->DisableWlanScanL() ) ; + } + CCHLOGSTRING( "CCCHServiceHandler::DisableWlanScan: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::SetConnectionInfo +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::SetConnectionInfo( + const TServiceConnectionInfo aServiceConnInfo ) + { + CCHLOGSTRING( "CCCHServiceHandler::SetConnectionInfo: IN" ); + TInt error( KErrNotFound ); + CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: serviceId %d", + aServiceConnInfo.iServiceSelection.iServiceId ); + CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: iType %d", + aServiceConnInfo.iServiceSelection.iType ); + CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: iSNAPId %d", + aServiceConnInfo.iSNAPId ); + CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: iIapId %d", + aServiceConnInfo.iIapId ); + CCHLOGSTRING2( "CCCHServiceHandler::SetConnectionInfo: iReserved %d", + aServiceConnInfo.iReserved ); + + if ( KErrNotFound != + ( error = FindService( aServiceConnInfo.iServiceSelection.iServiceId ) ) ) + { + TInt index( error ); + TRAP( error, iServices[ index ]->SetConnectionInfoL( + aServiceConnInfo ) ); + StartPluginUnloadTimer( ); + CCHLOGSTRING2 + ( "CCCHServiceHandler::SetConnectionInfo: error: %d", error ); + } + CCHLOGSTRING( "CCCHServiceHandler::SetConnectionInfo: OUT" ); + return error; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::GetConnectionInfo +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::GetConnectionInfo( + TServiceConnectionInfo& aServiceConnInfo ) + { + CCHLOGSTRING( "CCCHServiceHandler::GetConnectionInfo: IN" ); + TInt error( KErrNotFound ); + + if ( KErrNotFound != + ( error = FindService( aServiceConnInfo.ServiceId() ) ) ) + { + TInt index( error ); + TRAP( error, iServices[ index ]->GetConnectionInfoL( + aServiceConnInfo ) ); + StartPluginUnloadTimer( ); + CCHLOGSTRING2 + ( "CCCHServiceHandler::GetConnectionInfo: error: %d", error ); + } + CCHLOGSTRING( "CCCHServiceHandler::GetConnectionInfo: OUT" ); + return error; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::UsesWlanIapL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHServiceHandler::UsesWlanIap( + const TServiceSelection& aServiceSelection ) + { + CCHLOGSTRING( "CCCHServiceHandler::UsesWlanIap: IN" ); + TBool isWlanIap( EFalse ); + TServiceConnectionInfo serviceConnInfo( + aServiceSelection.iServiceId, aServiceSelection.iType, 0, 0 ); + CCHLOGSTRING3( "CCCHServiceHandler::UsesWlanIap: service:%d, type:%d", + aServiceSelection.iServiceId, aServiceSelection.iType ); + + TInt error = GetConnectionInfo( serviceConnInfo ); + + if( KErrNone == error ) + { + + CCHLOGSTRING3( "CCCHServiceHandler::UsesWlanIap: snap:%d, snap:%d", + serviceConnInfo.iSNAPId, serviceConnInfo.iIapId ); + if( 0 != serviceConnInfo.iSNAPId ) + { + CCHLOGSTRING( "CCCHServiceHandler::UsesWlanIapL: SNAP in use" ); + TInt count( 0 ); + TRAP( error, count = iCommDbWatcher->GetIapCountFromSnap( serviceConnInfo.iSNAPId, ETrue )); + if( KErrNone == error && 0 < count ) + { + isWlanIap = ETrue; + } + } + else if( 0 != serviceConnInfo.iIapId ) + { + CCHLOGSTRING( "CCCHServiceHandler::UsesWlanIapL: IAP in use" ); + + TRAP( error, isWlanIap = iCommDbWatcher->IsWlanApL( serviceConnInfo.iIapId ) ); + CCHLOGSTRING2( "CCCHServiceHandler::UsesWlanIap: error: %d", error ); + } + + + } + CCHLOGSTRING2( "CCCHServiceHandler::UsesWlanIap: OUT, value=%d", isWlanIap ); + return isWlanIap; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::IsConnectionDefined +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHServiceHandler::IsConnectionDefinedL( + const TServiceSelection& aServiceSelection ) + { + CCHLOGSTRING( "CCCHServiceHandler::IsConnectionDefined: IN" ); + TBool isOk( EFalse ); + __ASSERT_DEBUG( aServiceSelection.iType != ECCHUnknown, User::Panic( KNullDesC, KErrGeneral ) ); + TServiceConnectionInfo serviceConnInfo( + aServiceSelection.iServiceId, aServiceSelection.iType, 0, 0 ); + CCHLOGSTRING3( "CCCHServiceHandler::IsConnectionDefined: service:%d, type:%d", + aServiceSelection.iServiceId, aServiceSelection.iType ); + + TInt error = GetConnectionInfo( serviceConnInfo ); + User::LeaveIfError( error ); + + CCHLOGSTRING3( "CCCHServiceHandler::IsConnectionDefined: snap:%d, iap:%d", + serviceConnInfo.iSNAPId, serviceConnInfo.iIapId ); + if( 0 != serviceConnInfo.iSNAPId ) + { + TInt count( 0 ); + count = iCommDbWatcher->GetIapCountFromSnap( serviceConnInfo.iSNAPId, EFalse, ETrue ); + CCHLOGSTRING( "CCCHServiceHandler::IsConnectionDefined: SNAP in use" ); + if( KErrNone == error && 0 < count ) + { + isOk = ETrue; + } + } + else if( 0 != serviceConnInfo.iIapId ) + { + CCHLOGSTRING( "CCCHServiceHandler::IsConnectionDefined: IAP in use" ); + isOk = ETrue; + } + + CCHLOGSTRING2( "CCCHServiceHandler::IsConnectionDefined: OUT, value=%d", isOk ); + return isOk; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::IsServiceConnectivityDefined +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHServiceHandler::IsServiceConnectivityDefinedL( + const TServiceSelection& aServiceSelection ) + { + CCHLOGSTRING( "CCCHServiceHandler::IsServiceConnectivityDefined: IN" ); + + TBool isOk( EFalse ); + TInt error( KErrNone ); + TInt index = FindService( aServiceSelection.iServiceId ); + if ( KErrNotFound != index ) + { + if( ECCHUnknown == aServiceSelection.iType ) + { + for( TInt i = 0; i < iServices[ index ]->SubserviceCount(); i++ ) + { + TRAP( error, isOk = IsConnectionDefinedL( + TServiceSelection( aServiceSelection.iServiceId, + iServices[ index ]->GetSubserviceType( i ) ) ) ) ; + if( isOk ) + { + error = KErrNone; + break; + } + } + } + else + { + TRAP( error, isOk = IsConnectionDefinedL( aServiceSelection ) ); + } + } + CCHLOGSTRING3( + "CCCHServiceHandler::IsServiceConnectivityDefined: OUT, value=%d, error=%d", isOk, error ); + User::LeaveIfError( error ); + return isOk; + } + + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::HasWlanIap +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHServiceHandler::HasWlanIap( + const TServiceSelection& aServiceSelection ) + { + CCHLOGSTRING( "CCCHServiceHandler::HasWlanIap: IN" ); + + TBool isWlanIap( EFalse ); + TInt index = FindService( aServiceSelection.iServiceId ); + if ( KErrNotFound != index ) + { + if( ECCHUnknown == aServiceSelection.iType ) + { + for( TInt i = 0; i < iServices[ index ]->SubserviceCount(); i++ ) + { + isWlanIap = UsesWlanIap( + TServiceSelection( aServiceSelection.iServiceId, + iServices[ index ]->GetSubserviceType( i ) ) ) ; + if( isWlanIap ) + { + break; + } + } + } + else + { + isWlanIap = UsesWlanIap( aServiceSelection ); + } + StartPluginUnloadTimer( ); + } + CCHLOGSTRING2( "CCCHServiceHandler::HasWlanIap: OUT, value=%d", isWlanIap ); + return isWlanIap; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::ServiceCountL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::ServiceCountL( RMessage2 aMessage ) const + { + CCHLOGSTRING( "CCCHServiceHandler::ServiceCountL: IN" ); + + TPckgBuf pckgServiceCount; + aMessage.ReadL( 0, pckgServiceCount ); + TCCHSubserviceType type( + static_cast( aMessage.Int1() ) ); + + if ( ECCHUnknown == type ) + { + // Count of services + pckgServiceCount() = iServer.SPSHandler().GetServicesCountL(); + // Service count back to the client + aMessage.WriteL( 0, pckgServiceCount ); + } + else + { + // Count of services which contains subservices + pckgServiceCount() = ServiceCount( type ); + // Service count back to the client + aMessage.WriteL( 0, pckgServiceCount ); + } + + CCHLOGSTRING( "CCCHServiceHandler::ServiceCountL: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::GetServicesL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::GetServicesL( RMessage2 aMessage ) + { + CCHLOGSTRING( "CCCHServiceHandler::GetServicesL: IN" ); + // outstanding request for service, but SpSettings notify timer still running + if( iHandleNotifyDelayTimer->IsActive() ) + { + CCHLOGSTRING( "CCCHServiceHandler::GetServicesL - Forced handling of notify" ); + iHandleNotifyDelayTimer->Cancel(); + HandleDelayedNotifyEvent(); + } + TInt count = iServices.Count(); + TInt index( KErrNotFound ); + if ( count ) + { + CCHLOGSTRING2( "CCCHServiceHandler::GetServicesL service count:%d ", count ); + TUint32 serviceId = aMessage.Int0(); + TCCHSubserviceType type ( ECCHUnknown ); + type = static_cast( aMessage.Int1() ); + + if ( KErrNotFound == aMessage.Int0() ) + { + serviceId = KErrNone; + } + else if ( serviceId != KErrNone ) + { + count = 1; + } + + + CArrayFixFlat* serviceArray = + new( ELeave )CArrayFixFlat( count ); + CleanupStack::PushL( serviceArray ); + + TCCHService service; + // Get all services + if ( KErrNone == serviceId ) + { + CCHLOGSTRING( "CCCHServiceHandler::GetServicesL KErrNone == serviceId" ); + if ( type == ECCHUnknown ) + { + for ( TInt i( 0 ); i < count; i++ ) + { + iServices[ i ]->FillServiceInfo( service ); + serviceArray->AppendL( service ); + } + } + else + { + for ( TInt i( 0 ); i < count; i++ ) + { + if ( iServices[ i ]->SubserviceExist( type ) ) + { + iServices[ i ]->FillServiceInfo( service ); + serviceArray->AppendL( service ); + } + } + } + } + // Get specified service + else + { + if ( type == ECCHUnknown ) + { + index = FindService( serviceId ); + CCHLOGSTRING2( "CCCHServiceHandler::GetServicesL index:%d", index ); + + if ( KErrNotFound != index ) + { + iServices[ index ]->FillServiceInfo( service ); + serviceArray->AppendL( service ); + } + } + else + { + CCHLOGSTRING( "CCCHServiceHandler::GetServicesL Else" ); + TServiceSelection selection( serviceId, type ); + index = ServiceExist( selection ); + if ( KErrNotFound != index ) + { + iServices[ index ]->FillServiceInfo( service ); + serviceArray->AppendL( service ); + } + } + } + + TUint32 length = serviceArray->Count() * sizeof( TCCHService ); + + if ( length ) + { + TPtrC8 servicePtr; + servicePtr.Set( + reinterpret_cast( &( *serviceArray )[ 0 ] ), + length ); + aMessage.WriteL( 2, servicePtr ); + } + else + { + User::Leave( KErrNotFound ); + } + + CleanupStack::PopAndDestroy( serviceArray ); + } + else + { + User::Leave( KErrNotFound ); + } + CCHLOGSTRING( "CCCHServiceHandler::GetServicesL: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::GetServiceState +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::GetServiceState( const RMessage2 aMessage ) + { + CCHLOGSTRING( "CCCHServiceHandler::GetServiceStateL: IN" ); + + TUint32 serviceId( 0 ); + TCCHSubserviceType type ( ECCHUnknown ); + TPckgBuf status; + serviceId = aMessage.Int0(); + type = static_cast( aMessage.Int1() ); + + TInt error( FindService( serviceId ) ); + TInt errorState = KErrNone; + + if ( KErrNotFound != error ) + { + TInt index( error ); + TRAP( error, + { + aMessage.ReadL( 2, status ); + errorState = iServices[ index ]->GetStatus( type, status() ); + if( errorState == KErrNone ) + { + aMessage.WriteL( 2, status ); + } + } ); + if( KErrNone == error ) + { + if( errorState == KErrNone ) + { + error = iServices[ index ]->GetError( type ); + } + else + { + error = errorState; + } + } + StartPluginUnloadTimer( ); + } + + CCHLOGSTRING2( + "CCCHServiceHandler::GetServiceStateL: return %d OUT", error ); + return error; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::GetServiceState +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TCCHSubserviceState CCCHServiceHandler::ServiceState( + const TUint aServiceId ) + { + CCHLOGSTRING( "CCCHServiceHandler::ServiceState: IN" ); + + TCCHSubserviceState state( ECCHUninitialized ); + TInt error( FindService( aServiceId ) ); + + if ( KErrNotFound != error ) + { + state = iServices[ error ]->GetState(); + } + + CCHLOGSTRING2( + "CCCHServiceHandler::ServiceState: return %d OUT", state ); + return state; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::GetServiceInfo +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::GetServiceInfo( const RMessage2 aMessage ) + { + CCHLOGSTRING( "CCCHServiceHandler::GetServiceInfo: IN" ); + TBuf buffer; + + TPckgBuf serviceConnInfoPckg; + + TInt error = KErrNone; + TRAP( error, + { + aMessage.ReadL( 0, serviceConnInfoPckg ); + } ); + + if( error ) + { + return error; + } + + TServiceConnectionInfo conninfo; + + conninfo.iServiceSelection.iServiceId = serviceConnInfoPckg().iServiceSelection.iServiceId; + conninfo.iServiceSelection.iType = serviceConnInfoPckg().iServiceSelection.iType; + conninfo.iServiceSelection.iParameter = serviceConnInfoPckg().iServiceSelection.iParameter; + + error = ServiceExist( conninfo.iServiceSelection ); + + if ( KErrNotFound != error ) + { + TInt index( error ); + + if( conninfo.iServiceSelection.iParameter == ECchServiceInfo ) + { + TRAP( error, + { + iServices[ index ]->GetServiceInfoL( + buffer, conninfo.iServiceSelection.iType ); + aMessage.WriteL( 1, buffer ); + } ); + } + StartPluginUnloadTimer( ); + } + CCHLOGSTRING2( "CCCHServiceHandler::GetServiceInfo: return %d OUT", error ); + return error; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::ReserveService +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::ReserveService( const RMessage2 aMessage ) + { + CCHLOGSTRING( "CCCHServiceHandler::ReserveService: IN" ); + + TServiceSelection serviceSelection(aMessage.Int0(), + static_cast( aMessage.Int1() ) ); + + TInt error( ServiceExist( serviceSelection ) ); + + if ( KErrNotFound != error ) + { + TInt index( error ); + TRAP( error, + { + iServices[ index ]->ReserveServiceL( + serviceSelection.iType ); + } ); + } + CCHLOGSTRING2( "CCCHServiceHandler::ReserveService: return %d OUT", error ); + return error; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::FreeService +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::FreeService( const RMessage2& aMessage ) + { + CCHLOGSTRING( "CCCHServiceHandler::FreeService: IN" ); + + TServiceSelection serviceSelection(aMessage.Int0(), + static_cast( aMessage.Int1() ) ); + + TInt error( ServiceExist( serviceSelection ) ); + + if ( KErrNotFound != error ) + { + TInt index( error ); + TRAP( error, + { + iServices[ index ]->FreeServiceL( + serviceSelection.iType ); + } ); + } + CCHLOGSTRING2( "CCCHServiceHandler::FreeService: return %d OUT", error ); + return error; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::IsReserved +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::IsReserved( RMessage2 aMessage ) const + { + CCHLOGSTRING( "CCCHServiceHandler::IsReserved: IN" ); + + + TServiceSelection serviceSelection(aMessage.Int0(), + static_cast( aMessage.Int1() ) ); + TInt error( KErrNone ); + + TPckgBuf pckgIsReserved; + TRAP( error, aMessage.ReadL( 2, pckgIsReserved ) ); + + error = ServiceExist( serviceSelection ); + + if ( KErrNotFound != error ) + { + TInt index( error ); + TRAP( error, + { + pckgIsReserved() = iServices[ index ]->IsReservedL( + serviceSelection.iType ); + } ); + } + + + if ( KErrNotFound != error ) + { + // Service's reference count back to the client + TRAP( error, aMessage.WriteL( 2, pckgIsReserved ) ); + } + + + CCHLOGSTRING( "CCCHServiceHandler::IsReserved: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::ServiceExist +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::ServiceExist( TServiceSelection aSelection ) const + { + CCHLOGSTRING( "CCCHServiceHandler::ServiceExist: IN" ); + TBool exist( EFalse ); + TInt index( FindService( aSelection.iServiceId ) ); + + if ( KErrNotFound != index ) + { + exist = iServices[ index ]->SubserviceExist( aSelection.iType ); + } + CCHLOGSTRING( "CCCHServiceHandler::ServiceExist: OUT" ); + return !exist ? KErrNotFound : index; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::FindService +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::FindService( TUint32 aServiceId ) const + { + TBool exist( EFalse ); + TInt index( KErrNotFound ); + CCHLOGSTRING2( "CCCHServiceHandler::FindService: serviceId %d", + aServiceId ); + for ( TInt i( 0 ); i < iServices.Count() && !exist; i++ ) + { + exist = iServices[ i ]->GetServiceId() == aServiceId; + index = i; + } + return !exist ? KErrNotFound : index; + } +// --------------------------------------------------------------------------- +// CCCHServiceHandler::HandleNotifyChange +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::HandleNotifyChange( TServiceId aServiceId ) + { + CCHLOGSTRING( "CCCHServiceHandler::HandleNotifyChange IN" ); + + CancelHandleNotifyDelayTimer(); + StartHandleNotifyDelayTimer(); + iDelayedHandleNotifyServiceId = aServiceId; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::EnableNotifyChange +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::EnableNotifyChange() + { + TRACE_ENTRY_POINT; + // Subscribe to service change notifies + TRAP_IGNORE( iNotifier->NotifyChangeL( iServiceIds ) ); + TRACE_EXIT_POINT; + } +// --------------------------------------------------------------------------- +// CCCHServiceHandler::DisableNotifyChange +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::DisableNotifyChange() + { + TRACE_ENTRY_POINT; + iNotifier->Cancel(); + TRACE_EXIT_POINT; + } +// --------------------------------------------------------------------------- +// CCCHServiceHandler::ServiceCount +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::ServiceCount( const TCCHSubserviceType aType ) const + { + CCHLOGSTRING2( "CCCHServiceHandler::ServiceCount: type: %d",aType ); + + TInt count( 0 ); + + for ( TInt i( 0 ); i < iServices.Count(); i++ ) + { + if ( KErrNotFound != iServices[ i ]->FindSubservice( aType ) ) + { + count++; + } + } + + CCHLOGSTRING2( "CCCHServiceHandler::ServiceCount: count: %d", count ); + + return count; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::HandleError +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::HandleError( TInt /*aError*/ ) + { + + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::HandleWLANIapAdded +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::HandleWLANIapAdded( TInt aSNAPId ) + { + CCHLOGSTRING( "CCCHServiceHandler::HandleWLANIapAdded: IN" ); + TBool startScan( EFalse ); + TCCHSubserviceState serviceState( ECCHUninitialized ); + TCCHSubserviceType serviceType( ECCHUnknown ); + + // go through all services & subservices + for( TInt i = 0; i < iServices.Count(); i++ ) + { + for ( TInt j = 0; j < iServices[ i ]->SubserviceCount(); j++ ) + { + serviceType = iServices[ i ]->GetSubserviceType( j ); + TInt error = iServices[ i ]->GetStatus( serviceType, serviceState ); + + if( KErrNone == error ) + { + // if we have a connecting or enabled service + if( !iServer.FeatureManager().OfflineMode() && + ( ECCHConnecting == serviceState || ECCHEnabled == serviceState ) ) + { + TUint serviceId = iServices[ i ]->GetServiceId(); + TServiceConnectionInfo serviceConnInfo( serviceId, serviceType, 0, 0 ); + GetConnectionInfo( serviceConnInfo ); + + // with a snap with new wlan iap, we start wlan scan + if( aSNAPId == serviceConnInfo.iSNAPId && 0 != aSNAPId ) + { + startScan = ETrue; + } + } + } + } + } + if( startScan ) + { + CCHLOGSTRING( "CCCHServiceHandler::HandleWLANIapAdded; starting wlan scan" ); + TRAP_IGNORE( iWlanExtension->ForceEnableWlanScanL() ); + iServer.ConnMonHandler().ScanNetworks( ETrue ); + } + CCHLOGSTRING( "CCCHServiceHandler::HandleWLANIapAdded: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::GetSubserviceTypesL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::GetSubserviceTypesL( + const TUint aServiceId, + RArray& aSubserviceTypes ) const + { + TInt index( FindService( aServiceId ) ); + if ( KErrNotFound != index ) + { + aSubserviceTypes.Reset(); + for ( TInt i( 0 ); i < iServices[ index ]->SubserviceCount(); i++ ) + { + CCHLOGSTRING2( " Service contains subservice: %d", + iServices[ index ]->GetSubserviceType( i ) ); + + aSubserviceTypes.Append( + iServices[ index ]->GetSubserviceType( i ) ); + } + } + else + { + User::Leave( KErrNotFound ); + } + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::SetStartupFlag +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CCCHServiceHandler::SetStartupFlag( + TServiceSelection aSelection, + TBool aLoadAtStartUp ) const + { + TInt exist( FindService( aSelection.iServiceId ) ); + if ( KErrNotFound != exist ) + { + exist = iServices[ exist ]->SetStartupFlag( + aSelection.iType, aLoadAtStartUp ); + } + return exist; + } + +// --------------------------------------------------------------------------- +// CCCHServiceHandler::HandleRestartL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHServiceHandler::HandleRestartL() + { + // In restart situation all services and subservices goes to + // disabled state, after restart we will make reregistration + CCHLOGSTRING( "CCHServiceHandler::HandleRestartL() IN" ); + for ( TInt i( 0 ); i < iServices.Count(); i++ ) + { + for ( TInt j( 0 ); j < iServices[ i ]->SubserviceCount(); j++ ) + { + iServices[ i ]->GetSubserviceL( + iServices[ i ]->GetSubserviceType( j ) ).SetError( KErrCancel ); + iServices[ i ]->GetSubserviceL( + iServices[ i ]->GetSubserviceType( j ) ).SetState( ECCHDisabled ); + iServices[ i ]->GetSubserviceL( + iServices[ i ]->GetSubserviceType( j ) ).StatusChanged(); + } + } + CCHLOGSTRING( "CCHServiceHandler::HandleRestartL() OUT" ); + } + +// ========================== OTHER EXPORTED FUNCTIONS ======================= + +// End of File