diff -r 000000000000 -r 09774dfdd46b internetradio2.0/networkcontrollersrc/irnetworkcontroller.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/internetradio2.0/networkcontrollersrc/irnetworkcontroller.cpp Mon Apr 19 14:01:53 2010 +0300 @@ -0,0 +1,1189 @@ +/* +* Copyright (c) 2006-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: ?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" + +//for ALR/SNAP +#include +#include + + +const TInt KMaxIRUAProfLength = 250; // Max length of the UAProf string +const TInt KIRDefaultUAProfBufferSize = 0x80; +const TUint KIRESockMessageSlots = 16; +const TUint32 KIRUniqueWlanId = 0x2000883F; // Just to make it unique +const TInt KArraySize = 5; +const TInt KWlanStringMaxLength = 9; +const TInt KTwo = 2; + + +// 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++; + 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::GetAccessPointList +// Reset the connection status to Disconnected statet +// --------------------------------------------------------------------------- +// +EXPORT_C const CDesCArray* CIRNetworkController::GetAccessPointList() const +{ + IRLOG_DEBUG( "CIRNetworkController::GetAccessPointList" ); + return iIapList; +} + +// --------------------------------------------------------------------------- +// CIRNetworkController::GetBearerList +// Reset the connection status to Disconnected statet +// +EXPORT_C const RArray CIRNetworkController::GetBearerList() const +{ + IRLOG_DEBUG( "CIRNetworkController::GetBearerList" ); + return iBearerList; +} + +// --------------------------------------------------------------------------- +// CIRNetworkController::GetNetworkList +// Reset the connection status to Disconnected statet +// --------------------------------------------------------------------------- +// +EXPORT_C const RArray CIRNetworkController::GetNetworkList() const +{ + IRLOG_DEBUG( "CIRNetworkController::GetNetworkList" ); + return iNetworkList; +} + +// --------------------------------------------------------------------------- +// CIRNetworkController::GetApList +// Reset the connection status to Disconnected statet +// --------------------------------------------------------------------------- +// +EXPORT_C const RArray CIRNetworkController::GetApList() const +{ + IRLOG_DEBUG( "CIRNetworkController::GetApList" ); + return iIapIdList; +} + +// --------------------------------------------------------------------------- +// 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() ) + { + // 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) + { + iIRNetworkConnection->Start(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)." ); +} + +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)); + + delete iMobility; + 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(); + iBearerList.Close(); + iNetworkList.Close(); + iIapIdList.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(); + iBearerList.Reset(); + iNetworkList.Reset(); + iIapIdList.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() ); + iBearerList.AppendL( static_cast(iapRecord->iBearer) ); + iNetworkList.AppendL( static_cast(iapRecord->iNetwork) ); + iIapIdList.AppendL( iapRecord->RecordId() ); + + 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()); + iBearerList.AppendL(static_cast (iapRecord->iBearer)); + iNetworkList.AppendL(static_cast (iapRecord->iNetwork)); + iIapIdList.AppendL(iapRecord->RecordId()); + } + 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); + TUint32 WlanIdentifier(KIRUniqueWlanId); + iBearerList.AppendL(WlanIdentifier); + iNetworkList.AppendL((TUint32)KErrNotFound); + iIapIdList.AppendL((TUint32)KErrNotFound); + } +#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" ); + 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; i < iActiveNetworkObserverArray.Count(); i++) + { + iActiveNetworkObserverArray[i]->ResetPendingRequests(aValue); + } +}