diff -r 608f67c22514 -r 896e9dbc5f19 internetradio2.0/irnetworkcontroller/src/irnetworkcontroller.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/internetradio2.0/irnetworkcontroller/src/irnetworkcontroller.cpp Wed Aug 18 09:40:26 2010 +0300 @@ -0,0 +1,1181 @@ +/* +* Copyright (c) 2007 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: +* +*/ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "irdebug.h" +#include "irfilteredapreader.h" +#include "irnetworkcontroller.h" +#include "irnetworkobserver.h" +#include "irsettings.h" +#include "iractivenetworkobserver.h" + +const TInt KMaxIRUAProfLength = 250; // Max length of the UAProf string +const TInt KIRDefaultUAProfBufferSize = 0x80; +const TUint KIRESockMessageSlots = 16; +const TInt KArraySize = 5; +const TInt KWlanStringMaxLength = 9; +const TInt KTwo = 2; + +// --------------------------------------------------------------------------- +// define in WebUtilsSDKCRKeys.h +// --------------------------------------------------------------------------- +// +const TUid KCRUidWebUtils = {0x101F8731};//Web APIs removal and Internet Radio build break + +// --------------------------------------------------------------------------- +// define in WebUtilsInternalCRKeys.h +// --------------------------------------------------------------------------- +// +// Compatability fragment of useragent string +const TUint32 KWebUtilsUsrAg2 = 0x00000001; + +// PlatformVersion fragment of useragent string +const TUint32 KWebUtilsUsrAg3 = 0x00000002; + +// MidPVersion fragment of useragent string +const TUint32 KWebUtilsUsrAg4 = 0x00000003; + +// CLDConfiguration fragment of useragent string +const TUint32 KWebUtilsUsrAg5 = 0x00000004; + +// Url to useragent profile +const TUint32 KWebUtilsUaProf = 0x00000008; +// To Format the UAProf string +_LIT( KIRUAProfSpace," " ); +// WLan ( generic ) name string +_LIT( KIRWLanName,"Easy WLAN" ); + + +// ----------------------------------------------------------------------------------------------- +// Creates an Instance of CIRNetworkController +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C CIRNetworkController* CIRNetworkController::OpenL( MIRNetworkController* aObserver ) + { + IRLOG_DEBUG( "CIRNetworkController::OpenL - Entering" ); + CIRNetworkController* networkController = reinterpret_cast( Dll::Tls() ); + + if ( !networkController ) + { + networkController = new ( ELeave ) CIRNetworkController; + CleanupClosePushL( *networkController ); + networkController->iSingletonInstances = 1; + networkController->ConstructL( aObserver ); + User::LeaveIfError( Dll::SetTls( networkController ) ); + networkController->iSingletonInstances = 0; + CleanupStack::Pop( networkController ); + } + networkController->iSingletonInstances++; + if ( NULL != aObserver ) + { + networkController->iObserver = aObserver; + networkController->iIRNetworkObserver->SetObserver( aObserver ); + } + IRLOG_DEBUG( "CIRNetworkController::OpenL - Exiting." ); + return networkController; + } + +// ----------------------------------------------------------------------------------------------- +// Conditionally destroys the IRNetworkController object +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C void CIRNetworkController::Close() + { + IRLOG_DEBUG2( "CIRNetworkController::Close - singleton instances=%d", iSingletonInstances ); + iSingletonInstances--; + + if ( iSingletonInstances == 0 ) + { + delete this; + } + IRLOG_DEBUG( "CIRNetworkController::Close - Exiting." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::GetIRConnection +// Returns the instance of RConnection +// The same RConnection object is used across the entire iRAPP components to +// provide central arbiter and monitoring of Network Connection +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C RConnection& CIRNetworkController::GetIRConnection() + { + IRLOG_DEBUG( "CIRNetworkController::GetIRConnection - Entering" ); + // If the RConnection is open return the reference + switch ( iNetworkConnectionState ) + { + case EIRNetworkConnectionActive: + { + // Connection is active and ready to use return the reference + return ( *iIRNetworkConnection ); + } + case EIRNetworkConnectionInActive: + { + // Connection is not active and application cannot continue hence panic + _LIT( KComponentName,"NetworkController" ); + User::Panic( KComponentName,KErrCouldNotConnect ); + } + break; + default: + { + // no implementation + } + break; + } + // Inserted to remove the compiler warning + IRLOG_DEBUG( "CIRNetworkController::GetIRConnection - Exiting." ); + return ( *iIRNetworkConnection ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::GetIRSocketServer +// Returns the instance of RSocketServ +// The same RSocketServ object is used across the entire iRAPP components to +// provide central arbiter and monitoring of Network Connection +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C RSocketServ& CIRNetworkController::GetIRSocketServer() + { + IRLOG_DEBUG( "CIRNetworkController::GetIRSocketServer - Entering" ); + switch ( iSocketServerConnectionState ) + { + case EIRSocketServerActive: + { + // Connection to Socket Server is active hence return the reference + return iIRSocketServer; + } + case EIRSocketServerInActive: + { + // Connection to Socket Server not open hence open and return the reference + // Connection is not active and application cannot continue hence panic + _LIT( KComponentName,"NetworkController" ); + User::Panic( KComponentName,KErrCouldNotConnect ); + } + break; + default: + { + // no implemenatation + } + break; + } + // Inserted to remove the compiler warning + IRLOG_DEBUG( "CIRNetworkController::GetIRSocketServer - Exiting." ); + return iIRSocketServer; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::GetWapProfString +// Returns a HBufC pointer to the x-wap-profile string +// Transfers the ownership of the returned HBufC8 object +// The caller must takecare of deleting the returned object +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C HBufC8* CIRNetworkController::GetWapProfString() + { + IRLOG_DEBUG( "CIRNetworkController::GetWapProfString" ); + return iIRWapProf; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::GetUAProfString +// Returns a HBufC pointer to the UAProf string +// Transfers the ownership of the returned HBufC8 object +// The caller must takecare of deleting the returned object +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C HBufC8* CIRNetworkController::GetUAProfString() + { + IRLOG_DEBUG( "CIRNetworkController::GetUAProfString" ); + return iIRUAProf; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::GetNetworkStatus +// Returns the variable which indicates if connection is active or not +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C TBool CIRNetworkController::GetNetworkStatus() const + { + IRLOG_DEBUG( "CIRNetworkController::GetNetworkStatus" ); + return iIsConnectedToNetwork; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::GetIAPId +// Gets the IAP Id of the chosen IAP +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C TInt CIRNetworkController::GetIAPId( TUint32& aIapId ) const + { + IRLOG_DEBUG( "CIRNetworkController::GetIAPId - Entering" ); + TInt retVal( KErrNone ); + if ( iIsConnectedToNetwork ) + { + if ( iIRNetworkObserver->iIsIAPIdAvailable ) + { + aIapId = iIRNetworkObserver->iIAPId; + } + } + else + { + retVal = KErrNotFound; + } + IRLOG_DEBUG( "CIRNetworkController::GetIAPId - Exiting." ); + return retVal; + } + +// --------------------------------------------------------------------------- +// CIRNetworkController::ChooseAccessPointL +// Configures the Access Point which is used by all the components for network +// connectivity +// --------------------------------------------------------------------------- +// + + +EXPORT_C void CIRNetworkController::ChooseAccessPointL(TBool aDefaultConnection) + { + IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Entering" ); + if (iHandingOver) + { + if (iObserver) + { + iObserver->IRNetworkEventL(ENetworkConnectionConnecting); + } + IRLOG_DEBUG("CIRNetworkController::ChooseAccessPointL, ALR is handing over, Exiting"); + return; + } + + iIRNetworkObserver->SetNetworkMonitoring( ETrue ); + iDefaultConnection = aDefaultConnection; + + // Always validate the Access Points status + if ( ValidateAccessPointsL() ) + { + if ( NULL != iMobility ) + { + iMobility->Cancel(); + delete iMobility; + iMobility = NULL; + } + // Connect to the Symbian Socket Server + iIRNetworkConnection->Close(); + iIRSocketServer.Close(); + TInt ReturnErrorCode = iIRSocketServer.Connect( KIRESockMessageSlots ); + + if(ReturnErrorCode != KErrNone ) + { + // Error in opening the connection to SocketServer + iSocketServerConnectionState = EIRSocketServerInActive; + IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Exiting ( 1 )." ); + return ; + } + + // Connection to RSocketServ is sucessful + iSocketServerConnectionState = EIRSocketServerActive; + + // Open the RConnection over the iIRSocketServer + ReturnErrorCode = iIRNetworkConnection->Open(iIRSocketServer); + + if( ReturnErrorCode != KErrNone ) + { + // Error in opening the connection + iNetworkConnectionState = EIRNetworkConnectionInActive; + IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Exiting ( 2 )." ); + return ; + } + + //Added for ALR/SNAP + if ( !IsActive() ) + { + if (iDefaultConnection) + { + TConnPrefList prefList; + TExtendedConnPref extPrefs; + + extPrefs.SetSnapPurpose(CMManager::ESnapPurposeInternet); + extPrefs.SetNoteBehaviour(TExtendedConnPref::ENoteBehaviourConnDisableNotes); + prefList.AppendL(&extPrefs); + iIRNetworkConnection->Start(prefList, iStatus); + } + else + { + TCommDbConnPref connPref; + connPref.SetDialogPreference(ECommDbDialogPrefPrompt); + iIRNetworkConnection->Start(connPref, iStatus) ; + } + + // Set the NetworkController state + iNetworkControllerState = EConnectingToNetwork; + + SetActive(); + iIsConnectRequestIssued = ETrue; + if ( iObserver ) + { + IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - notify ENetworkConnectionConnecting" ); + iObserver->IRNetworkEventL( ENetworkConnectionConnecting ); + } + } + IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Exiting ( 3 )." ); + return ; + } + else + { + iObserver->IRNetworkEventL(EAccessPointSelectionCancelled ); + } + IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Exiting ( 4 )." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::CancelConnecting +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C void CIRNetworkController::CancelConnecting() + { + IRLOG_DEBUG("CIRNetworkController::CancelConnecting(), Entering"); + iIRNetworkObserver->Cancel(); + Cancel(); + ResetConnectionStatus(); + IRLOG_DEBUG("CIRNetworkController::CancelConnecting(), Exiting"); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::IsOfflineMode +// This api is used to determine if the phone is in offline mode +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C TBool CIRNetworkController::IsOfflineMode() + { + IRLOG_DEBUG( "CIRNetworkController::IsOfflineMode" ); + // System defined value for offline mode is 5 + const TInt KOfflineMode = 5; + TInt returnValue = 0; + returnValue = DetermineCurrentProfile(); + if ( returnValue == KOfflineMode ) + { + IRLOG_DEBUG( "CIRNetworkController::IsOfflineMode - Exiting ( 1 )." ); + return ETrue; + } + IRLOG_DEBUG( "CIRNetworkController::IsOfflineMode - Exiting ( 2 )." ); + return EFalse; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::IsWlanSupported +// This api is used to determine if the phone supports WLan usage +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C TBool CIRNetworkController::IsWlanSupported() const + { + IRLOG_DEBUG( "CIRNetworkController::IsWlanSupported" ); + return iIsWlanSupported; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::ResetConnectionStatus +// Reset the connection status to Disconnected statet +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C void CIRNetworkController::ResetConnectionStatus() + { + IRLOG_DEBUG( "CIRNetworkController::ResetConnectionStatus - Entering" ); + iIsConnectRequestIssued = EFalse; + iNetworkConnectionState = EIRNetworkConnectionInActive; + iIsConnectedToNetwork = EFalse; + iConnectionPresent = EFalse; + IRLOG_DEBUG( "CIRNetworkController::ResetConnectionStatus - Exiting." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::IdentifyConnectionType +// Used to determine the type of connection +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C TIRConnectionType CIRNetworkController::IdentifyConnectionType() const + { + IRLOG_DEBUG( "CIRNetworkController::IdentifyConnectionType" ); + IRRDEBUG2( "CIRNetworkController::IdentifyConnectionType - Entering iConnectionType = %d", iIRNetworkObserver->iIRConnectionType ); + + return iIRNetworkObserver->iIRConnectionType; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::DetermineCurrentProfile +// Used to determine the current profile +// ----------------------------------------------------------------------------------------------- +// +TInt CIRNetworkController::DetermineCurrentProfile() const + { + IRLOG_DEBUG( "CIRNetworkController::DetermineCurrentProfile" ); + TInt value = KErrNone; + + TRAPD( err, + CRepository* cRepositoryHandle = CRepository::NewLC( KCRUidProfileEngine ); + cRepositoryHandle->Get( KProEngActiveProfile,value ); + CleanupStack::PopAndDestroy( cRepositoryHandle ); ) + if ( err != KErrNone ) + { + value = err; + } + + IRLOG_DEBUG( "CIRNetworkController::DetermineCurrentProfile - Exiting." ); + return value; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::CheckFeatureL +// Pops up the access point list. +// ----------------------------------------------------------------------------------------------- +// +TBool CIRNetworkController::CheckFeatureL( TInt aFeatureId ) const + { + IRLOG_DEBUG( "CIRNetworkController::CheckFeatureL" ); + return CFeatureDiscovery::IsFeatureSupportedL( aFeatureId ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::CIRNetworkController +// Default C++ Constructor +// ----------------------------------------------------------------------------------------------- +// +CIRNetworkController::CIRNetworkController(): CActive( + CActive::EPriorityHigh ) + { + // Add the AO to the ActiveScheduler + IRLOG_DEBUG( "CIRNetworkController::CIRNetworkController- Entering" ); + CActiveScheduler::Add( this ); + // Initialize the states + iNetworkConnectionState = EIRNetworkConnectionInActive; + iSocketServerConnectionState = EIRSocketServerInActive; + iNetworkControllerState = EInActive; + + + IRLOG_DEBUG( "CIRNetworkController::CIRNetworkController - Exiting." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::~CIRNetworkController +// Default C++ Destructor +// ----------------------------------------------------------------------------------------------- +// +CIRNetworkController::~CIRNetworkController() + { + IRLOG_DEBUG( "CIRNetworkController::~CIRNetworkController- Entering" ); + _LIT( KErrorMsg,"Method Close not called" ); + __ASSERT_ALWAYS( iSingletonInstances == 0, User::Panic( KErrorMsg, KErrCorrupt ) ); + + if ( NULL != iMobility ) + { + iMobility->Cancel(); + delete iMobility; + iMobility = NULL; + } + + if ( IsActive() ) + { + Cancel(); + } + if ( iIRNetworkConnection ) + { + iIRNetworkConnection->Close(); + delete iIRNetworkConnection; + } + + // Set all the state variables to indicate network connection is closed + delete iIRUAProf; + delete iIRWapProf; + if ( iIRSettings ) + { + iIRSettings->Close(); + iIRSettings = NULL; + } + delete iIRNetworkObserver; + iIRSocketServer.Close(); + + if ( iIapList ) + { + iIapList->Reset(); + delete iIapList; + iIapList = NULL; + } + + if ( iDataTransferTracker ) + { + delete iDataTransferTracker; + iDataTransferTracker = NULL; + } + if ( iLogoDataTransferTracker ) + { + delete iLogoDataTransferTracker; + iLogoDataTransferTracker = NULL; + } + iObserver = NULL; + + iActiveNetworkObserverArray.Close(); + + Dll::FreeTls(); + IRLOG_DEBUG( "CIRNetworkController::~CIRNetworkController - Exiting." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::ConstructL +// Second Phase construction. +// aObserver pointer to the observer class if an observer is needed +// ----------------------------------------------------------------------------------------------- +// +void CIRNetworkController::ConstructL( MIRNetworkController* aObserver ) + { + IRLOG_DEBUG( "CIRNetworkController::ConstructL- Entering" ); + iObserver = aObserver; + iIRNetworkObserver = CIRNetworkObserver::NewL(this); + iIRNetworkObserver->SetObserver( iObserver ); + + // Create instance of DataTransferTracker ( Byte Counter Impl ) + iDataTransferTracker = CIRDataTransferTracker::NewL(); + iLogoDataTransferTracker = CIRDataTransferTracker::NewL(); + + iIRNetworkConnection = new ( ELeave ) RConnection; + + iIRSettings = CIRSettings::OpenL(); + + BuildUAProfStringL(); + iIapList = new ( ELeave ) CDesCArrayFlat( KArraySize ); + + QueryCommsForIAPL(); + + IRLOG_DEBUG( "CIRNetworkController::ConstructL - Exiting." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::QueryCommsForIAPL +// Determines the available access points using CommsDat Api +// voilates PCLint Error 40 --Undeclared identifier 'KFeatureIdProtocolWlan' +// as defined in featureinfo.h +// ----------------------------------------------------------------------------------------------- +// +void CIRNetworkController::QueryCommsForIAPL() + { + IRLOG_DEBUG( "CIRNetworkController::QueryCommsForIAPL- Entering" ); + + // Reset all the comms info + iIapList->Reset(); + +#ifndef __WINS__ + CIRFilteredApReader* filteredReader = CIRFilteredApReader:: + NewLC( CIRFilteredApReader::KIRFilterWAPOnly | + CIRFilteredApReader::KIRFilterWAPMandatory | + CIRFilteredApReader::KIRFilterEasyWLAN ); + + CCDIAPRecord* iapRecord = filteredReader->FirstRecordL(); + + while ( iapRecord ) + { + CleanupStack::PushL( iapRecord ); + + iIapList->AppendL( iapRecord->iRecordName.GetL() ); + + CleanupStack::PopAndDestroy( iapRecord ); + iapRecord = filteredReader->NextRecordL(); + } + CleanupStack::PopAndDestroy( filteredReader ); +#else + CMDBSession* dbSession = CMDBSession::NewL(CMDBSession::LatestVersion()); + CleanupStack::PushL(dbSession); + + CMDBRecordSet* iapSet = new (ELeave) CMDBRecordSet< + CCDIAPRecord> (KCDTIdIAPRecord); + CleanupStack::PushL(iapSet); + + TRAP_IGNORE(iapSet->LoadL(*dbSession)); + + for ( TInt i = 0; i < iapSet->iRecords.Count(); i++ ) + { + CCDIAPRecord* iapRecord = + static_cast (iapSet->iRecords[i]); + iIapList->AppendL(iapRecord->iRecordName.GetL()); + } + CleanupStack::PopAndDestroy(2, dbSession); +#endif + + // If WLan is supported on the device then add the WLan option + // to the IAP List +#ifndef __WINS__ + iIsWlanSupported = CheckFeatureL( KFeatureIdProtocolWlan ); + if ( iIsWlanSupported ) + { + TBuf wlanString; + wlanString.Copy( KIRWLanName ); + iIapList->AppendL( wlanString ); + } +#endif + + iIapList->Compress(); + + IRLOG_DEBUG( "CIRNetworkController::QueryCommsForIAPL - Exiting." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::BuildUAProfStringL +// Queries the system and extracts the UAProf information +// Used by IRDataProvider and IRStreamSource +// ----------------------------------------------------------------------------------------------- +// +void CIRNetworkController::BuildUAProfStringL() + { + IRLOG_DEBUG( "CIRNetworkController::BuildUAProfStringL- Entering" ); + // Create space on heap for the UAProf String + iIRUAProf = HBufC8::NewL( KMaxIRUAProfLength ); + iIRWapProf = HBufC8::NewL( KMaxIRUAProfLength ); + HBufC* cenRepPtr; + TPtr8 irUAProf = iIRUAProf->Des(); + TPtr8 irWapProf = iIRWapProf->Des(); + irUAProf.Append( iIRSettings->GetIrappVersionL() ); + + cenRepPtr = NULL; + irUAProf.Append( KIRUAProfSpace ); + // extract UAProf sub-string from cenrep + cenRepPtr = CentralRepositoryStringValueL( KCRUidWebUtils,KWebUtilsUsrAg3 ); + // append it to form the UAProf + irUAProf.Append( cenRepPtr->Des() ); + delete cenRepPtr; + cenRepPtr = NULL; + + irUAProf.Append( KIRUAProfSpace ); + // extract UAProf sub-string from cenrep + cenRepPtr = CentralRepositoryStringValueL( KCRUidWebUtils,KWebUtilsUsrAg2 ); + // append it to form the UAProf + irUAProf.Append( cenRepPtr->Des() ); + delete cenRepPtr; + cenRepPtr = NULL; + + irUAProf.Append( KIRUAProfSpace ); + // extract UAProf sub-string from cenrep + cenRepPtr = CentralRepositoryStringValueL( KCRUidWebUtils,KWebUtilsUsrAg4 ); + // append it to form the UAProf + irUAProf.Append( cenRepPtr->Des() ); + delete cenRepPtr; + cenRepPtr = NULL; + + irUAProf.Append( KIRUAProfSpace ); + // extract UAProf sub-string from cenrep + cenRepPtr = CentralRepositoryStringValueL( KCRUidWebUtils,KWebUtilsUsrAg5 ); + // append it to form the UAProf + irUAProf.Append( cenRepPtr->Des() ); + delete cenRepPtr; + cenRepPtr = NULL; + // trim out the quotes + irUAProf.Delete( irUAProf.Length()-1,1 ); + // extract x-wap-profile string from cenrep + cenRepPtr = CentralRepositoryStringValueL( KCRUidWebUtils,KWebUtilsUaProf ); + // append it to form the UAProf + irWapProf.Copy( cenRepPtr->Des() ); + delete cenRepPtr; + cenRepPtr = NULL; + + IRLOG_DEBUG( "CIRNetworkController::BuildUAProfStringL - Exiting." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::CentralRepositoryStringValueL +// Retrievs the string from Central Repository for the specified key and cen rep uid +// Transfers the ownership of the returned HBufC object +// The caller must takecare of deleting the returned object* +// ----------------------------------------------------------------------------------------------- +// +HBufC* CIRNetworkController::CentralRepositoryStringValueL( + const TUid& aRepositoryUid, TUint32 aKey ) const + { + IRLOG_DEBUG( "CIRNetworkController::CentralRepositoryStringValueL- Entering" ); + CRepository* pRepository = CRepository::NewL( aRepositoryUid ); + CleanupStack::PushL( pRepository ); + + TInt length = KIRDefaultUAProfBufferSize; + HBufC* valueString = HBufC::NewLC( length ); + TInt error( KErrTooBig ); + do + { + TPtr ptr = valueString->Des(); + error = pRepository->Get( aKey, ptr ); + if ( error == KErrTooBig ) + { + CleanupStack::PopAndDestroy( valueString ); + length = KTwo * length; + valueString = HBufC::NewLC( length ); + } + } while ( error == KErrTooBig ); + + if ( error ) + { + TPtr ptr = valueString->Des(); + ptr.Copy( KNullDesC() ); + } + + CleanupStack::Pop( valueString ); + CleanupStack::PopAndDestroy( pRepository ); + IRLOG_DEBUG( "CIRNetworkController::CentralRepositoryStringValueL - Exiting." ); + return valueString; + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::ValidateAccessPointsL( +// Validates the access point availablity etc. +// voilates PCLint Error 40 --Undeclared identifier 'KFeatureIdProtocolWlan' +// as defined in featureinfo.h +// ----------------------------------------------------------------------------------------------- +// +TBool CIRNetworkController::ValidateAccessPointsL() + { + IRLOG_DEBUG( "CIRNetworkController::ValidateAccessPointsL- Entering" ); + TBool status = ETrue; + #ifndef __WINS__ + // Check if the phone is in offline mode + // If yes, do not allow GPRS access + // If phone is in offline mode and device does not support + // WIFI then exit the application + // Do not make this check in Wins + //violates PC Lint error : Error 40: Undeclared identifier KFeatureIdProtocolWlan + if ( IsOfflineMode() && !( CheckFeatureL( KFeatureIdProtocolWlan) ) ) + { + // The phone is in offline mode and WLan is not available + iObserver->IRNetworkEventL( EDisplayOfflineMode ); + status = EFalse; + } + // If phone is not in offline mode and no access points are defined + // check if device has WIFI support then try to launch WIFI + // selection if there is no support then display a message + if ( !IsOfflineMode() && iIapList->MdcaCount() == 0 ) + { + // Check if there is WIFI support + //violates PC Lint error : Error 40: Undeclared identifier KFeatureIdProtocolWlan + if ( !CheckFeatureL( KFeatureIdProtocolWlan ) ) + { + iObserver->IRNetworkEventL( EDisplayNoAccessPointsDefined ); + status = EFalse; + } + } + #endif + IRLOG_DEBUG( "CIRNetworkController::ValidateAccessPointsL - Exiting." ); + return status; + } + +// Derived from CActive +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::RunL +// The function is called by the active scheduler when a request completion event occurs, +// ----------------------------------------------------------------------------------------------- +// +void CIRNetworkController::RunL() + { + IRLOG_INFO2( "CIRNetworkController::RunL - iStatus=%d", iStatus.Int() ); + iHandingOver = EFalse; + + TInt statusCode = iStatus.Int(); + + if ( iStatus == KErrNone ) + { + HandleRunLSuccessL(); + } + else + { + HandleRunLErrorL( statusCode ); + } + IRLOG_DEBUG( "CIRNetworkController::RunL - Exiting." ); + } + +// ----------------------------------------------------------------------------------------------- +// CIRNetworkController::DoCancel() +// Cancels the pending requests on the CIRNetworkController Active object +// ----------------------------------------------------------------------------------------------- +// +void CIRNetworkController::DoCancel() + { + IRLOG_DEBUG( "CIRNetworkController::DoCancel - Entering" ); + if ( NULL != iMobility ) + { + iMobility->Cancel(); + delete iMobility; + iMobility = NULL; + } + iIRNetworkConnection->Stop(); + iIRNetworkConnection->Close(); + iIRSocketServer.Close(); + IRLOG_DEBUG( "CIRNetworkController::DoCancel - Exiting." ); + } + +// ----------------------------------------------------------------------------- +// CIRNetworkController::InitializeHttpSession +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIRNetworkController::InitializeHttpSessionL( const RHTTPSession& aHTTPSession, + MIRDataTransferTracker::TIRTransferCategory aCategory ) + { + IRLOG_DEBUG( "CVRConnection::InitializeHttpSessionL - enter" ); + + iDataTransferTracker->BindL( aHTTPSession, aCategory ); + + RStringF sockserv = aHTTPSession.StringPool().StringF( + HTTP::EHttpSocketServ, RHTTPSession::GetTable()); + CleanupClosePushL( sockserv ); + + RStringF connection = aHTTPSession.StringPool().StringF( + HTTP::EHttpSocketConnection, RHTTPSession::GetTable()); + CleanupClosePushL( connection ); + + RHTTPConnectionInfo cInfo = aHTTPSession.ConnectionInfo(); + cInfo.SetPropertyL( sockserv, THTTPHdrVal( iIRSocketServer.Handle() ) ); + cInfo.SetPropertyL(connection, THTTPHdrVal( + reinterpret_cast (iIRNetworkConnection))); + CleanupStack::PopAndDestroy( &connection ); // sockserv.close, connection.close + CleanupStack::PopAndDestroy( &sockserv ); // sockserv.close, connection.close + + IRLOG_DEBUG( "CIRNetworkController::InitializeHttpSessionL - exit" ); + } + +// ----------------------------------------------------------------------------- +// CIRNetworkController::RegisterLogoDataTransferTrackerL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIRNetworkController::RegisterLogoDataTransferTrackerL( RHTTPSession& aHTTPSession ) + { + IRLOG_DEBUG( "CVRConnection::InitializeHttpSessionL - enter" ); + + iLogoDataTransferTracker->BindL(aHTTPSession, + MIRDataTransferTracker::EIRTransferCategoryIsds); + + RStringF sockserv = aHTTPSession.StringPool().StringF( + HTTP::EHttpSocketServ, RHTTPSession::GetTable()); + CleanupClosePushL( sockserv ); + + RStringF connection = aHTTPSession.StringPool().StringF( + HTTP::EHttpSocketConnection, RHTTPSession::GetTable()); + CleanupClosePushL( connection ); + + RHTTPConnectionInfo cInfo = aHTTPSession.ConnectionInfo(); + cInfo.SetPropertyL( sockserv, THTTPHdrVal( iIRSocketServer.Handle() ) ); + cInfo.SetPropertyL(connection, THTTPHdrVal( + reinterpret_cast (iIRNetworkConnection))); + CleanupStack::PopAndDestroy( &connection ); // sockserv.close, connection.close + CleanupStack::PopAndDestroy( &sockserv ); // sockserv.close, connection.close + + // Subscribe to logo byte counter info + iLogoDataTransferTracker->SetObserver( this ); + + IRLOG_DEBUG( "CIRNetworkController::RegisterLogoDataTransferTrackerL - exit" ); + } + +// ----------------------------------------------------------------------------- +// CIRNetworkController::DataTransferTracker() +// ----------------------------------------------------------------------------- +// +EXPORT_C MIRDataTransferTracker& CIRNetworkController::DataTransferTracker() + { + IRLOG_DEBUG( "CIRNetworkController::DataTransferTracker" ); + return *iDataTransferTracker; + } + +// ----------------------------------------------------------------------------- +// CIRNetworkController::LogoDataTransferTracker() +// ----------------------------------------------------------------------------- +// +EXPORT_C MIRDataTransferTracker& CIRNetworkController::LogoDataTransferTracker() + { + IRLOG_DEBUG( "CIRNetworkController::LogoDataTransferTracker" ); + return *iLogoDataTransferTracker; + } + +// ----------------------------------------------------------------------------- +// CIRNetworkController::LogoDataTransferTracker() +// ----------------------------------------------------------------------------- +// +void CIRNetworkController::HandleDataTransferEventL( + const MIRDataTransferTracker::TIRDataTransferPckg& aData ) + { + IRLOG_DEBUG( "CIRNetworkController::HandleDataTransferEventL - Entering" ); + iDataTransferTracker->RawDataTransferredL(aData.iBytesSentTotal, + aData.iBytesReceivedTotal, + MIRDataTransferTracker::EIRTransferCategoryIsds ); + IRLOG_DEBUG( "CIRNetworkController::HandleDataTransferEventL - Exiting" ); + } + +// ----------------------------------------------------------------------------- +// CIRNetworkController::PreferredCarrierAvailable() +// ----------------------------------------------------------------------------- +// +void CIRNetworkController::PreferredCarrierAvailable( TAccessPointInfo aOldAPInfo, + TAccessPointInfo aNewAPInfo, + TBool aIsUpgrade, + TBool aIsSeamless ) + { + IRLOG_DEBUG("CIRNetworkController::PreferredCarrierAvailable - Entering"); + + (void)aOldAPInfo; + (void)aNewAPInfo; + (void)aIsUpgrade; + IRLOG_DEBUG5("CIRNetworkController::PreferredCarrierAvailable, old ap : %d, new ap : %d, aIsUpgrade : %d, aIsSeamless : %d", + aOldAPInfo.AccessPoint(), aNewAPInfo.AccessPoint(), aIsUpgrade, aIsSeamless); + + if (aIsSeamless) + { + // It is Seamless. E.g. Mobile IP enabled. + } + else + { + // sockets used by the connection should be closed here. + + // We ask to migrate to the Preferred Carrier. + if (!IsOfflineMode()) + { + //handling over connection may take some time, during handling over connection, + //application should be in disconnected state + TRAP_IGNORE( iObserver->IRNetworkEventL(ENetworkConnectionDisconnected ); ) + + iIRNetworkObserver->SetNetworkMonitoring(EFalse); + + iMobility->MigrateToPreferredCarrier(); + iHandingOver = ETrue; + } + } + + IRLOG_DEBUG("CIRNetworkController::PreferredCarrierAvailable - Exiting"); + } + +// ----------------------------------------------------------------------------- +// CIRNetworkController::NewCarrierActive() +// ----------------------------------------------------------------------------- +// +void CIRNetworkController::NewCarrierActive( TAccessPointInfo aNewAPInfo, TBool aIsSeamless ) + { + IRLOG_DEBUG("CIRNetworkController::NewCarrierActive - Entering"); + (void)aNewAPInfo; + IRLOG_DEBUG3("CIRNetworkController::NewCarrierActive, new ap : %d, aIsSeamless : %d", + aNewAPInfo.AccessPoint(), aIsSeamless); + + if (aIsSeamless) + { + // It is Seamless. E.g. Mobile IP enabled. + } + else + { + // sockets used by the connection should be re-opened here. + // We accept the new IAP. + + iMobility->NewCarrierAccepted(); + + iIsConnectRequestIssued = EFalse; + iNetworkConnectionState = EIRNetworkConnectionActive; + iIsConnectedToNetwork = ETrue; + iConnectionPresent = ETrue; + + iIRNetworkObserver->SetNetworkMonitoring(ETrue); + iIRNetworkObserver->InitializeNetworkObserver(); + } + + IRLOG_DEBUG("CIRNetworkController::NewCarrierActive - Exiting"); + } + +// ----------------------------------------------------------------------------- +// CIRNetworkController::Error() +// ----------------------------------------------------------------------------- +// +void CIRNetworkController::Error( TInt /*aError*/ ) + { + IRLOG_DEBUG( "CIRNetworkController::Error" ); + // Does nothing for the moment + } + +// ----------------------------------------------------------------------------- +// HandleRunLSuccessL() +// Handles the success case of Network connection in RunL +// ------------------------------------------------------------------------------------------------- +// +void CIRNetworkController::HandleRunLSuccessL() + { + IRLOG_DEBUG( "CIRNetworkController::HandleRunLSuccessL - Entering" ); + + switch ( iNetworkControllerState ) + { + case EConnectingToNetwork: + { + iIsConnectedToNetwork = ETrue; + // Connection to network sucessful + iNetworkConnectionState = EIRNetworkConnectionActive; + iConnectionPresent = ETrue; + iIsConnectRequestIssued = EFalse; + iIRNetworkObserver->InitializeNetworkObserver(); + } + break; + default: + { + // no implementation + } + break; + } + + if ( !iMobility ) + { + iMobility = CActiveCommsMobilityApiExt::NewL( *iIRNetworkConnection, + *this ); + } + IRLOG_DEBUG( "CIRNetworkController::HandleRunLSuccessL - Exiting" ); + } + +// ------------------------------------------------------------------------------------------------- +// HandleRunLErrorL() +// Handles the error case of Network connection in RunL +// ------------------------------------------------------------------------------------------------- +// +void CIRNetworkController::HandleRunLErrorL( TInt aStatusCode ) + { + IRLOG_DEBUG( "CIRNetworkController::HandleRunLErrorL - Entering" ); + + switch ( iNetworkControllerState ) + { + case EConnectingToNetwork: + { + // Connection to network failure + iNetworkConnectionState = EIRNetworkConnectionInActive; + iIsConnectedToNetwork = EFalse; + iConnectionPresent = EFalse; + iIsConnectRequestIssued = EFalse; + if ( aStatusCode != KErrCancel ) + { + if (iDefaultConnection) + { + //give user the second chance to select access point manually + ChooseAccessPointL(EFalse); + } + else + { + iObserver->IRNetworkEventL(EDisplayNetworkMessageNoConnectivity); + } + } + else + { + iObserver->IRNetworkEventL( EAccessPointSelectionCancelled ); + ResetPendingRequests( EFalse ); + } + } + break; + + default: + { + // no implementation + } + break; + } + + IRLOG_DEBUG( "CIRNetworkController::HandleRunLErrorL - Exiting" ); + } + +// ------------------------------------------------------------------------------------------------- +// Registers the observer that will be notified for +// a network connection. +// Observer requires notification to reissue pending request +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C void CIRNetworkController::RegisterActiveNetworkObserverL( MIRActiveNetworkObserver& + aActiveNetworkObserver ) + { + IRLOG_DEBUG( "CIRNetworkController::RegisterActiveNetworkObserverL - Entering" ); + iActiveNetworkObserverArray.AppendL( &aActiveNetworkObserver ); + IRLOG_DEBUG( "CIRNetworkController::RegisterActiveNetworkObserverL - Exiting" ); + } + +// ----------------------------------------------------------------------------------------------- +// DeleteActiveNetworkObserver() +// Used to remove an observer for roaming events from the observer array +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C void CIRNetworkController::DeleteActiveNetworkObserver( MIRActiveNetworkObserver& + aActiveNetworkObserver ) + { + IRLOG_DEBUG( "CIRNetworkController::DeleteActiveNetworkObserver - Entering" ); + TInt index = iActiveNetworkObserverArray.Find( &aActiveNetworkObserver ); + + if ( index != KErrNotFound ) + { + iActiveNetworkObserverArray.Remove( index ); + } + + IRLOG_DEBUG( "CIRNetworkController::DeleteActiveNetworkObserver - Exiting" ); + } + +// ----------------------------------------------------------------------------------------------- +// NotifyActiveNetworkObserversL() +// Used to notify all observers for network events about a change in network event +// ----------------------------------------------------------------------------------------------- +// +EXPORT_C void CIRNetworkController::NotifyActiveNetworkObserversL( TIRNetworkEvent aEvent ) + { + IRLOG_DEBUG( "CIRNetworkController::NotifyActiveNetworkObserversL - Entering" ); + + for ( TInt i=iActiveNetworkObserverArray.Count()-1; i>=0; i-- ) + { + iActiveNetworkObserverArray[i]->NotifyActiveNetworkObserversL( aEvent ); + } + + + IRLOG_DEBUG( "CIRNetworkController::NotifyActiveNetworkObserversL - Exiting" ); + } + +// ------------------------------------------------------------------------------------------------- +// IsHandingOverConnection() +// Indicates if the Hand over of Network connection has happened +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C TBool CIRNetworkController::IsHandingOverConnection() + { + IRLOG_DEBUG("CIRNetworkController::IsHandingOverConnection - Entering"); + IRLOG_DEBUG("CIRNetworkController::IsHandingOverConnection - Exiting"); + return iHandingOver; + } + +// ------------------------------------------------------------------------------------------------- +// Reset member iHandingOver to EFalse. +// ------------------------------------------------------------------------------------------------- +// +void CIRNetworkController::ResetHandingOverConnection() + { + IRLOG_DEBUG("CIRNetworkController::ResetHandingOverConnection(), Entering"); + iHandingOver = EFalse; + IRLOG_DEBUG("CIRNetworkController::ResetHandingOverConnection(), Exiting"); + } + +// ------------------------------------------------------------------------------------------------- +// Notifies observers when user cancels network connection, to reset +// the pending requests +// ResetPendingRequests() +// ------------------------------------------------------------------------------------------------- +// +void CIRNetworkController::ResetPendingRequests( TBool aValue ) + { + for ( TInt i=0; iResetPendingRequests( aValue ); + } + }