diff -r f742655b05bf -r d38647835c2e convergedconnectionhandler/cchserver/src/cchconnmonhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/convergedconnectionhandler/cchserver/src/cchconnmonhandler.cpp Wed Sep 01 12:29:57 2010 +0100 @@ -0,0 +1,655 @@ +/* +* Copyright (c) 2007-2010 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: CCCHConnMonHandler implementation +* +*/ + + +// INCLUDE FILES +#include "cchconnmonhandler.h" +#include "cchserverbase.h" +#include "cchlogger.h" +#include "cchservicehandler.h" +#include "cchconnmonhandlernotifier.h" + +// EXTERNAL DATA STRUCTURES +// None + +// EXTERNAL FUNCTION PROTOTYPES +// None + +// CONSTANTS +// None + +// MACROS +// None + +// LOCAL CONSTANTS AND MACROS +const TInt KPeriodicTimerInterval( 5000000 ); // 5sec. + +// MODULE DATA STRUCTURES +// None + +// LOCAL FUNCTION PROTOTYPES +// None + +// FORWARD DECLARATIONS +// None + +// ============================= LOCAL FUNCTIONS ============================= + +// ============================ MEMBER FUNCTIONS ============================= + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::CCCHConnMonHandler +// C++ default constructor can NOT contain any code, that might leave. +// --------------------------------------------------------------------------- +// +CCCHConnMonHandler::CCCHConnMonHandler( CCCHServerBase& aServer ) : + CActive( CActive::EPriorityStandard ), + iState( EUninitialized ), + iServer( aServer ) + { + CActiveScheduler::Add( this ); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::ConstructL +// Symbian 2nd phase constructor can leave. +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::ConstructL() + { + User::LeaveIfError( iConnMon.ConnectL() ); + NotifyL(); + iConnChangeListenerTimer = CPeriodic::NewL( CActive::EPriorityIdle ); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::NewL +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CCCHConnMonHandler* CCCHConnMonHandler::NewL( CCCHServerBase& aServer ) + { + CCCHConnMonHandler* self = CCCHConnMonHandler::NewLC( aServer ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::NewLC +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CCCHConnMonHandler* CCCHConnMonHandler::NewLC( CCCHServerBase& aServer ) + { + CCCHConnMonHandler* self = new (ELeave) CCCHConnMonHandler( aServer ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// Destructor +CCCHConnMonHandler::~CCCHConnMonHandler() + { + CCHLOGSTRING( "CCCHConnMonHandler::~CCCHConnMonHandler" ); + if ( iConnChangeListenerTimer ) + { + iConnChangeListenerTimer->Cancel(); + } + delete iConnChangeListenerTimer; + StopNotify(); + Cancel(); + iPendingRequests.Close(); + iUnsolvedConnIds.Close(); + iConnIapIds.Close(); + iAvailableSNAPs.Close(); + iAvailableIAPs.Close(); + iConnMon.Close(); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::ScanNetworks +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::ScanNetworks( + TBool aWlanScan, MCCHConnMonHandlerNotifier* aObserver ) + { + CCHLOGSTRING( "CCCHConnMonHandler::ScanNetworks: IN" ); + + if ( aWlanScan ) + { + iNetworkScanningObserver = aObserver; + GetIaps( EBearerIdAll ); + } + + CCHLOGSTRING( "CCCHConnMonHandler::ScanNetworks: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::ScanNetworksCancel +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::ScanNetworksCancel() + { + Cancel(); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::IsSNAPAvailable +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHConnMonHandler::IsSNAPAvailable( TUint aSNAPId ) const + { + return ( KErrNotFound == iAvailableSNAPs.Find( aSNAPId ) ) + ? EFalse : ETrue; + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::IsIapAvailable +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CCCHConnMonHandler::IsIapAvailable( TUint aIapId ) const + { + return ( KErrNotFound == iAvailableIAPs.Find( aIapId ) ) + ? EFalse : ETrue; + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::SetSNAPsAvailabilityChangeListener +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::SetSNAPsAvailabilityChangeListener( + MCCHConnMonHandlerNotifier* aObserver ) + { + CCHLOGSTRING( "CCCHConnMonHandler::SetSNAPsAvailabilityChangeListener" ); + iConnChangeListenerTimer->Cancel(); + iSNAPsAvailabilityObserver = aObserver; + if ( iSNAPsAvailabilityObserver ) + { + iConnChangeListenerTimer->Start( + KPeriodicTimerInterval, + KPeriodicTimerInterval, + TCallBack( PeriodicTimerCallBack, this ) ); + } + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::GetIaps +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::GetIaps( TConnMonBearerId aBearerId ) + { + if ( !IsActive() ) + { + iConnMon.GetPckgAttribute( aBearerId, + 0, + KIapAvailability, + iIapsBuf, + iStatus ); + iState = EGetIAPS; + SetActive(); + } + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::UpdateIapArray +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::UpdateIapArray( TConnMonIapInfo aIaps ) + { + CCHLOGSTRING2( "CCCHConnMonHandler::UpdateIapArray: IN count %d", + iAvailableIAPs.Count() ); + + iAvailableIAPs.Reset(); + TUint count( 0 ); + + // Copy TConnMonIapInfo to RArray so we can use RArray::Find method + while ( count < aIaps.iCount ) + { + iAvailableIAPs.Append( aIaps.iIap[ count ].iIapId ); + count++; + } + CCHLOGSTRING2( "CCCHConnMonHandler::UpdateIapArray: OUT count %d", + iAvailableIAPs.Count() ); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::GetSNAPs +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::GetSNAPs() + { + CCHLOGSTRING( "CCCHConnMonHandler::GetSNAPs: IN" ); + + if ( !IsActive() ) + { + iConnMon.GetPckgAttribute( EBearerIdAll, // some parameter + 0, // pass the size of buffer + KSNAPsAvailability, // specify the request + iSNAPbuf, // buffer for writing data + iStatus ); + iState = EGetSNAPs; + SetActive(); + } + + CCHLOGSTRING( "CCCHConnMonHandler::GetSNAPs: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::UpdateSnapArray +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::UpdateSnapArray( TConnMonSNAPInfo aSNAPs ) + { + CCHLOGSTRING2( "CCCHConnMonHandler::UpdateSnapArray: IN count %d", + iAvailableSNAPs.Count() ); + + iAvailableSNAPs.Reset(); + TUint count( 0 ); + // Copy TConnMonSNAPInfo to RArray so we can use RArray::Find method + while ( count < aSNAPs.iCount ) + { + iAvailableSNAPs.Append( aSNAPs.iSNAP[ count ].iSNAPId ); + count++; + } + CCHLOGSTRING2( "CCCHConnMonHandler::UpdateSnapArray: OUT count %d", + iAvailableSNAPs.Count() ); + + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::NotifyL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::NotifyL() + { + CCHLOGSTRING( "CCCHConnMonHandler::NotifyL: IN" ); + + iConnMon.NotifyEventL( *this ); + + // Thresholds + TInt err = iConnMon.SetUintAttribute( EBearerIdAll, + 0, + KBearerAvailabilityThreshold, + 1 ); + + CCHLOGSTRING2( "CCCHConnMonHandler::NotifyL: OUT", err ); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::StopNotify +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::StopNotify() + { + iConnMon.CancelNotifications(); + } + +// ---------------------------------------------------------------------------- +// CCCHConnMonHandler::PeriodicTimerCallBack +// The call back function. +// ---------------------------------------------------------------------------- +// +TInt CCCHConnMonHandler::PeriodicTimerCallBack( TAny* aAny ) + { + CCHLOGSTRING( "CCCHConnMonHandler::PeriodicTimerCallBack" ); + + CCCHConnMonHandler* self = static_cast( aAny ); + self->iConnChangeListenerTimer->Cancel(); + + if ( self->iSNAPsAvailabilityObserver ) + { + self->iSNAPsAvailabilityObserver-> + SNAPsAvailabilityChanged( KErrTimedOut ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::RunL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::RunL() + { + CCHLOGSTRING2( "CCCHConnMonHandler::RunL: IN error: %d", iStatus.Int() ); + + if ( KErrNone == iStatus.Int() ) + { + switch ( iState ) + { + case EGetIAPS: + { + UpdateIapArray( iIapsBuf() ); + GetSNAPs(); + } + break; + + case EGetSNAPs: + { + UpdateSnapArray( iSNAPbuf() ); + if ( iNetworkScanningObserver ) + { + iNetworkScanningObserver->NetworkScanningCompletedL( + iSNAPbuf(), KErrNone ); + iNetworkScanningObserver = NULL; + } + } + break; + + case EGetIAP: + { + CCHLOGSTRING2( "CCCHConnMonHandler::RunL: iap: %d", iConnIapId ); + TCCHConnectionInfo info; + info.iIapId = iConnIapId; + info.iConnId = iConnId; + + if ( KErrNotFound == iConnIapIds.Find( info ) ) + { + iConnIapIds.Append( info ); + } + iConnId = 0; + iConnIapId = 0; + + CCHLOGSTRING2( "CCCHConnMonHandler::RunL: unsolved conn count: %d", iUnsolvedConnIds.Count() ); + if ( iUnsolvedConnIds.Count() ) + { + GetIapId(); + } + } + break; + + case EGetConnectionCount: + { + CCHLOGSTRING2( "CCCHConnMonHandler::RunL: conn count: %d", iConnCount ); + TBool familiar( EFalse ); + TUint connId( KErrNone ); + TUint subConnCount( KErrNone ); + for ( TInt i( 1 ); i <= iConnCount; i++ ) + { + if ( !iConnMon.GetConnectionInfo( i, connId, subConnCount ) ) + { + familiar = EFalse; + for ( TInt j( 0 ); j < iConnIapIds.Count(); j++ ) + { + if ( connId == iConnIapIds[ j ].iConnId ) + { + CCHLOGSTRING2( "CCCHConnMonHandler::RunL: iap %d is familiar connection", iConnIapIds[ j ].iIapId ); + familiar = ETrue; + break; + } + } + + if ( !familiar && KErrNotFound == iUnsolvedConnIds.Find( connId ) ) + { + iUnsolvedConnIds.Append( connId ); + } + } + } + iConnCount = 0; + + CCHLOGSTRING2( "CCCHConnMonHandler::RunL: unsolved conn count: %d", iUnsolvedConnIds.Count() ); + if ( iUnsolvedConnIds.Count() ) + { + GetIapId(); + } + } + break; + + default: + break; + } + + + if ( iPendingRequests.Count() && !IsActive() ) + { + CCHLOGSTRING2( "CCCHConnMonHandler::RunL: request pending : %d", + iPendingRequests[ 0 ] ); + switch ( iPendingRequests[ 0 ] ) + { + case EGetIAP: + { + GetIapId(); + } + break; + + case EGetConnectionCount: + { + GetConnectionCount(); + } + break; + + default: + break; + } + + iPendingRequests.Remove( 0 ); + iPendingRequests.Compress(); + } + } + else + { + if ( iNetworkScanningObserver ) + { + iNetworkScanningObserver->NetworkScanningCompletedL( + iSNAPbuf(), iStatus.Int() ); + iNetworkScanningObserver = NULL; + } + } + + CCHLOGSTRING( "CCCHConnMonHandler::RunL: OUT" ); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::StartMonitoringConnectionChanges +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::StartMonitoringConnectionChanges() + { + iConnIapIds.Reset(); + + if ( !IsActive() ) + { + GetConnectionCount(); + } + else + { + iPendingRequests.Append( EGetConnectionCount ); + } + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::StopMonitoringConnectionChanges +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::StopMonitoringConnectionChanges( + RArray& aIapIds ) + { + aIapIds.Reset(); + for ( TInt i( 0 ); i < iConnIapIds.Count(); i++ ) + { + if ( KErrNotFound == aIapIds.Find( iConnIapIds[ i ].iIapId ) ) + { + aIapIds.Append( iConnIapIds[ i ].iIapId ); + } + } + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::GetConnectionCount +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::GetConnectionCount() + { + iState = EGetConnectionCount; + iConnMon.GetConnectionCount( iConnCount, iStatus ); + SetActive(); + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::GetIapId +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::GetIapId() + { + if ( iUnsolvedConnIds.Count() ) + { + iConnId = iUnsolvedConnIds[ 0 ]; + iUnsolvedConnIds.Remove( 0 ); + iUnsolvedConnIds.Compress(); + + iState = EGetIAP; + iConnMon.GetUintAttribute( iConnId, 0, KIAPId, iConnIapId, iStatus ); + SetActive(); + } + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::RemoveIapId +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::RemoveIapId( + TUint aConnId ) + { + for ( TInt i( 0 ); i < iConnIapIds.Count(); i++ ) + { + if ( aConnId == iConnIapIds[ i ].iConnId ) + { + iConnIapIds.Remove( i ); + iConnIapIds.Compress(); + break; + } + } + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::DoCancel +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::DoCancel() + { + iConnMon.CancelAsyncRequest( EConnMonGetPckgAttribute ); + if ( iNetworkScanningObserver ) + { + iNetworkScanningObserver->NetworkScanningCompletedL( + iSNAPbuf(), KErrCancel ); + iNetworkScanningObserver = NULL; + } + if ( iSNAPsAvailabilityObserver ) + { + iConnChangeListenerTimer->Cancel(); + iSNAPsAvailabilityObserver->SNAPsAvailabilityChanged( KErrCancel ); + iSNAPsAvailabilityObserver = NULL; + } + } + +// --------------------------------------------------------------------------- +// CCCHConnMonHandler::EventL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CCCHConnMonHandler::EventL( const CConnMonEventBase &aConnMonEvent ) + { + CCHLOGSTRING3 + ( "CCCHConnMonHandler::EventL: IN EventType = %d, ConnectionId = %d", + aConnMonEvent.EventType(), aConnMonEvent.ConnectionId() ); + + switch ( aConnMonEvent.EventType() ) + { + case EConnMonIapAvailabilityChange: + { + const CConnMonIapAvailabilityChange* eventIap = NULL; + eventIap = static_cast< const CConnMonIapAvailabilityChange* >( + &aConnMonEvent ); + + TConnMonIapInfo iaps = eventIap->IapAvailability(); + UpdateIapArray( iaps ); + } + break; + + case EConnMonSNAPsAvailabilityChange: + { + const CConnMonSNAPsAvailabilityChange* eventSNAP = NULL; + eventSNAP = static_cast< const CConnMonSNAPsAvailabilityChange* >( + &aConnMonEvent ); + + TConnMonSNAPInfo snaps = eventSNAP->SNAPAvailability(); + UpdateSnapArray( snaps ); + + if ( iSNAPsAvailabilityObserver ) + { + iConnChangeListenerTimer->Cancel(); + iSNAPsAvailabilityObserver->SNAPsAvailabilityChanged( KErrNone ); + } + } + break; + + case EConnMonCreateConnection: + { + const CConnMonCreateConnection* eventCreate = NULL; + eventCreate = static_cast< const CConnMonCreateConnection* >( + &aConnMonEvent ); + iUnsolvedConnIds.Append( eventCreate->ConnectionId() ); + + if ( !IsActive() ) + { + GetIapId(); + } + else + { + iPendingRequests.Append( EGetIAP ); + } + } + break; + + case EConnMonDeleteConnection: + { + const CConnMonDeleteConnection* eventDelete = NULL; + eventDelete = static_cast< const CConnMonDeleteConnection* >( + &aConnMonEvent ); + TUint connId = eventDelete->ConnectionId(); + + RemoveIapId( connId ); + } + break; + + default: + break; + } + CCHLOGSTRING( "CCCHConnMonHandler::EventL: OUT" ); + } + +// ========================== OTHER EXPORTED FUNCTIONS ======================= + +// End of File