diff -r 000000000000 -r 96612d01cf9f videofeeds/server/IptvNetworkSelection/src/CIptvNetworkSelection.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videofeeds/server/IptvNetworkSelection/src/CIptvNetworkSelection.cpp Mon Jan 18 20:21:12 2010 +0200 @@ -0,0 +1,1676 @@ +/* +* Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "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: Handles IAP selection and connection permissions.* +*/ + + + + +/* + +IAP selection procedure: +------------------------ + +Return iCurrentIap if it's feasible: + + 1. If Service has EReadOnlyIaps flag set and iCurrentIap is not found from iService + IAPs, set iCurrentIapIsFeasible to EFalse and jump to section 4. + 2. If iCiAiMatch exists, return it. [EXIT] + 3. If iCurrentIap is EGprs or ECsd type, return it. [EXIT] + 4. Run WLAN scan. + 5. If iCurrentIapIsFeasible is ETrue + 5.1 Calculate iCiSwiMatch + 5.2 If iCiSwiMatch exists, return it. [EXIT] + +iCurrentIap wasn't feasible, try to find from service IAPs list: + + 6. Put service IAPs to iAvailableIaps list. + 7. Check if WLAN is available, (iActiveIaps has WLAN IAP which is not on service IAPs). + 7.1 If WLAN is not available remove all WLAN IAPS from iAvailableIaps list. + 7.2 Choose best from iAvailableIaps. [EXIT] + 8. Remove all WLAN IAPs from iAvailableIaps list. + 9. Add iSiSwiMatch to iAvailableIaps list. + 10. Choose highest priority from iAvailableIaps. [EXIT] + +Note1: In offline mode hidden WLAN IAPs from service IAPS and current iap + are added to Scanned WLAN IAPs even if they are not found from the scan. + +Note2: If phone is in offline mode, then all EGprs and ECsd IAPs are filtered out + from iService IAPs and iCurrentIap. + +Note3: iCurrentIap is not feasible if service has EReadOnlyIaps flag set and iCurrentIap + is not found from service IAPs, ie iCiSiMatch does not contain value. +*/ + +// INCLUDE FILES +#include "CIptvNetworkSelection.h" +#include "CIptvServer.h" +#include "CIptvServiceManager.h" +#include +#include +#include "IptvDebug.h" +#include +#include + +#include //TConnectionInfo +#include +#include +#include + +#include +#include + +#include + +#include +#include +#include +#include + +// EXTERNAL DATA STRUCTURES + +// EXTERNAL FUNCTION PROTOTYPES + +// CONSTANTS + +#ifdef __WINSCW__ +const TInt KWlanScanSimulationTimerTime = 5000000; // 5 seconds +#endif + +// MACROS + +// LOCAL CONSTANTS AND MACROS + +#if IPTV_LOGGING_METHOD != 0 + +_LIT(KIptvNsWlan, "EWlan"); +_LIT(KIptvNsGprs, "EGprs"); +_LIT(KIptvNsCsd, "ECsd"); +_LIT(KIptvNsUnknown, "EUnknown"); + +#endif + +// MODULE DATA STRUCTURES + +// LOCAL FUNCTION PROTOTYPES + +// FORWARD DECLARATIONS + +// ============================= LOCAL FUNCTIONS =============================== + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::CIptvNetworkSelection +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CIptvNetworkSelection::CIptvNetworkSelection( CIptvServer& aServer ) +:CActive(EPriorityStandard), iServer(aServer) + { + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::ConstructL() + { + +#ifdef __WINSCW__ + iWlanScanSimulationTimer = CIptvTimer::NewL( EPriorityStandard, *this ); +#endif + + CActiveScheduler::Add( this ); + iGetUsedIapReqs.Reset(); + + //Initialize iOffline + MProfileEngine* engine = CreateProfileEngineL(); + CleanupReleasePushL( *engine ); + + if ( engine ) + { + if ( engine->ActiveProfileId() == EProfileOffLineId ) + { + iOffline = ETrue; + } + else + { + iOffline = EFalse; + } + } + + CleanupStack::PopAndDestroy( engine ); + + iProfChangeHandler = CProfileChangeNotifyHandler::NewL( this ); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CIptvNetworkSelection* CIptvNetworkSelection::NewL( CIptvServer& aServer ) + { + CIptvNetworkSelection* self = new( ELeave ) CIptvNetworkSelection( aServer ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + + return self; + } + + +// Destructor +CIptvNetworkSelection::~CIptvNetworkSelection() + { + Cancel(); + delete iActiveIaps; + delete iScannedWlanIaps; + delete iAvailableIaps; + iGetUsedIapReqs.Close(); + iConnMon.Close(); +#ifdef __WINSCW__ + delete iWlanScanSimulationTimer; +#endif + delete iProfChangeHandler; + delete iService; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::SetUsedIap +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::SetUsedIapL( TUint32 aIapId, + TUint32 aServiceId, + TBool aSetToDefaultForService, + TRespStatus& aRespStatus ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::SetUsedIapL() start"); + + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: setting %d as a current IAP in use.", aIapId); + iCurrentIap.iId = aIapId; + iCurrentIap.iValueExists = ETrue; + + if ( aSetToDefaultForService ) + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: adding to services' (%d) iap list too", aServiceId); + CIptvService* service = iServer.iServiceManager->GetServiceL( aServiceId, ETrue /* do open/close */ ); + if ( !service ) + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: service not found: %d", aServiceId); + aRespStatus = EServiceNotFound; + return; + } + + CleanupStack::PushL( service ); // 1-> + + TInt i; + TBool zeroPrioExists = EFalse; + + //try to delete iap if its there already + TIptvIap iap; + iap.iId = aIapId; + iap.iPriority = 0; //0 = the highest priority (king), prio has no effect on delete + TInt err = service->iIapList->DeleteIap( iap ); + + if ( err == KErrNone ) + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: There was already iap with id %d, deleted it", aIapId); + } + else + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: iap did not exist, didn't delete"); + } + + //move up priorities if there is priority 0 iap already + for ( i = 0; i < service->iIapList->Count(); i++ ) + { + if ( service->iIapList->IapL(i).iPriority == 0 ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: There was already prio 0"); + zeroPrioExists = ETrue; + break; + } + } + if ( zeroPrioExists ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: adding +1 to all priorities"); + for ( i = 0; i < service->iIapList->Count(); i++ ) + { + service->iIapList->IapL(i).iPriority += 1; + } + } + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: adding new IAP with prio 0"); + + service->iIapList->AddIap( iap ); + iServer.iServiceManager->UpdateServiceL( *service ); + CleanupStack::PopAndDestroy( service ); // <-1 + } + + aRespStatus = ESucceeded; + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::SetUsedIapL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::GetUsedIapReqL +// Called by Network Selection client +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::GetUsedIapReqL( TIptvGetUsedIapReq* aGetUsedIapReq ) + { + UpdateServiceL( aGetUsedIapReq->iServiceId ); + if ( !iService ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * No such service, aborting *"); + aGetUsedIapReq->iRespStatus = EServiceNotFound; + return; + } + + TInt destId( 0 ); + TBool invalidDest( EFalse ); + + CRepository* cenRep = CRepository::NewLC( KIptvAlrCenRepUid ); + if ( cenRep->Get( KIptvCenRepUsedSnapIdKey, destId ) != KErrNone ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * KIptvCenRepUsedSnapIdKey not found *"); + aGetUsedIapReq->iRespStatus = static_cast( ENoSuitableIapFound ); + invalidDest = ETrue; + } + else if ( destId == KIptvCenRepAPModeAlwaysAsk ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * KIptvCenRepUsedSnapIdKey always ask"); + aGetUsedIapReq->iRespStatus = static_cast( EFailedAlwaysAskSelected ); + invalidDest = ETrue; + } + + CleanupStack::PopAndDestroy( cenRep ); + + // Scan is useless, when always ask is selected. + if ( invalidDest && !( (iService->GetFlags() & CIptvService::EReadOnlyIaps ) ) ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: ALR//Always ask mode on or key not found"); + return; + } + + if ( (iService->GetFlags() & CIptvService::EReadOnlyIaps) ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * service has read only iaps *"); + } + + aGetUsedIapReq->iRespStatus = EProcessing; + UpdateAllButWlanListsL( *aGetUsedIapReq ); + + //informs client that response will arrive asyncrounously to callback function + aGetUsedIapReq->iRespStatus = EDoingWlanScan; + + //add TIptvGetUsedIapReq to list + iGetUsedIapReqs.AppendL( aGetUsedIapReq ); + +#ifdef __WINSCW__ + + //use timer to simulate event receiving + iWlanScanSimulationTimer->Cancel(); + iWlanScanSimulationTimer->After( KWlanScanSimulationTimerTime ); + +#else + + if ( !IsActive() ) + { + UpdateWlanScannedIapsL(); //async + } +#endif + + //Now we just wait call to RunL() (or TimerExpired() on WINSCW), + //RunL() converts SSIDS to IAPS and calls HandleGetUsedIapRequests() + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetUsedIapReqL() exit"); + return; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::HandleGetUsedIapRequests +// Called by RunL() when wlan scan has finished +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::HandleGetUsedIapRequests() + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::HandleGetUsedIapRequests() start"); + TInt i; + for ( i = 0; i < iGetUsedIapReqs.Count(); i++ ) + { + TRAPD( err, GetUsedIapAfterWlanScanL( *(iGetUsedIapReqs[i]) ) ); + if ( err == KErrNone ) + { + //inform the request owner + iGetUsedIapReqs[i]->iNsObserver->GetUsedIapResp( iGetUsedIapReqs[i] ); + } + else + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * failed to get used iap after wlan scan! *"); + iGetUsedIapReqs[i]->iRespStatus = static_cast(EGeneralError); + iGetUsedIapReqs[i]->iNsObserver->GetUsedIapResp( iGetUsedIapReqs[i] ); + } + } + iGetUsedIapReqs.Close(); //delete request items + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::HandleGetUsedIapRequests() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::CancelGetUsedIapReq +// ----------------------------------------------------------------------------- +// +TInt CIptvNetworkSelection::CancelGetUsedIapReq( MIptvNetworkSelectionObserver* aObserver ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::CancelGetUsedIapReq() start"); + TInt i; + + if ( iGetUsedIapReqs.Count() == 0 ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: no requests pending."); + return KErrNotFound; + } + + TBool found = EFalse; + for ( i = 0; i < iGetUsedIapReqs.Count() && !found; i++ ) + { + if ( iGetUsedIapReqs[i]->iNsObserver == aObserver ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: request removed, cancel resp sent."); + iGetUsedIapReqs[i]->iRespStatus = static_cast(ECancelled); + iGetUsedIapReqs[i]->iNsObserver->GetUsedIapResp( iGetUsedIapReqs[i] ); + iGetUsedIapReqs.Remove( i ); + found = ETrue; + } + } + + if ( iGetUsedIapReqs.Count() == 0 ) + { +#ifdef __WINSCW__ + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: this was the last request, cancel wlan scan simulation timer (WINSCW only)."); + iWlanScanSimulationTimer->Cancel(); +#else + // Cancel wlan scan + Cancel(); + iGetUsedIapReqs.Close(); +#endif + } + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::CancelGetUsedIapReq() exit"); + + if ( !found ) + { + return KErrNotFound; + } + else + { + return KErrNone; + } + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::GetUsedIapAfterWlanScanL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::GetUsedIapAfterWlanScanL( TIptvGetUsedIapReq& aGetUsedIapReq ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetUsedIapAfterWlanScanL() start"); + + //we update these again, AI might have changed + UpdateAllButWlanListsL( aGetUsedIapReq ); + +#ifndef __WINSCW__ // wlan stuff is not needed in winscw + // Note: This iOffLine check was added to fix the error TSIN-6YTDSJ + // "Video Center tries to connect via unavailable WLAN when refreshing + // video feed". In online mode the RConnectionMonitor does return the + // correct status of hidden WLAN APs so there is no need to add them + // manually. Manual addition is needed only in offline mode where platform + // cannot sniff for hidden APs (user authorisation would be required). + if ( iOffline ) + { + AddHiddenWlanSiIapsToSwiL(); + } +#endif + // ALR defined + // Used iap selected from SNAP with highest priority. + RCmManagerExt manager; + manager.OpenL(); + CleanupClosePushL( manager ); + + TInt destId( 0 ); + CRepository* cenRep = CRepository::NewLC( KIptvAlrCenRepUid ); + if( cenRep->Get( KIptvCenRepUsedSnapIdKey, destId ) != KErrNone ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * KIptvCenRepUsedSnapIdKey not found *"); + CleanupStack::PopAndDestroy( cenRep ); + CleanupStack::PopAndDestroy( &manager ); + aGetUsedIapReq.iRespStatus = static_cast(ENoSuitableIapFound); + return; + } + + CleanupStack::PopAndDestroy( cenRep ); + + // Check if read only iaps + if ( ( iService->GetFlags() & CIptvService::EReadOnlyIaps ) ) + { + delete iAvailableIaps; + iAvailableIaps = NULL; + iAvailableIaps = CIptvIapList::NewL(); + + TInt i; + +#ifndef __WINSCW__ + for ( i = 0; i < iScannedWlanIaps->Count(); i++ ) + { + iAvailableIaps->AddIap( iScannedWlanIaps->IapL( i ) ); + } +#endif //__WINSCW__ + + for( i = 0; i < iActiveIaps->Count(); i++ ) + { + iAvailableIaps->AddIap( iActiveIaps->IapL( i ) ); + } + + TInt t=0; + while( t < iService->iIapList->Count() ) + { + TInt temp = iService->iIapList->IapL( t ).iId; + + RCmConnectionMethodExt conn; + CleanupClosePushL( conn ); + TRAPD( err, conn = + manager.ConnectionMethodL( iService->iIapList->IapL( t ).iId ) ); + if( err == KErrNone ) + { + if( KUidWlanBearerType != conn.GetIntAttributeL( CMManager::ECmBearerType ) ) + { + CleanupStack::PopAndDestroy( &conn ); + CleanupStack::PopAndDestroy( &manager ); + // Found read only iap other than wlan + SelectL( aGetUsedIapReq, iService->iIapList->IapL( t ).iId ); + return; + } + } + TInt s=0; + while( s < iAvailableIaps->Count() ) + { + if( iService->iIapList->IapL( t ).iId == iAvailableIaps->IapL( s ).iId ) + { + CleanupStack::PopAndDestroy( &conn ); + CleanupStack::PopAndDestroy( &manager ); + // Found suitable read only iap, select + SelectL( aGetUsedIapReq, iService->iIapList->IapL( t ).iId ); + return; + } + s++; + } + CleanupStack::PopAndDestroy( &conn ); + t++; + } + } + + //Check destination key + if( destId == KIptvCenRepAPModeAlwaysAsk ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * KIptvCenRepUsedSnapIdKey always ask *"); + CleanupStack::PopAndDestroy( &manager ); + aGetUsedIapReq.iRespStatus = static_cast(EFailedAlwaysAskSelected); + return; + } + + RCmDestinationExt cmDest = manager.DestinationL( destId ); + CleanupClosePushL( cmDest ); + + TInt cmCount = cmDest.ConnectionMethodCount(); + TInt bestIap( 0 ); + TInt alrIap( 0 ); + TUint bearerType( 0 ); + +#ifdef __WINSCW__ + if( cmCount ) + { + // In WINSW supposedly first priority can be used + RCmConnectionMethodExt connMethod = cmDest.ConnectionMethodL( 0 ); + CleanupClosePushL( connMethod ); + bestIap = connMethod.GetIntAttributeL( CMManager::ECmIapId ); + CleanupStack::PopAndDestroy( &connMethod ); + } +#else // __WINSCW__ + + delete iAvailableIaps; + iAvailableIaps = NULL; + iAvailableIaps = CIptvIapList::NewL(); + + TInt i; + for ( i = 0; i < iScannedWlanIaps->Count(); i++ ) + { + iAvailableIaps->AddIap( iScannedWlanIaps->IapL( i ) ); + } + for( i = 0; i < iActiveIaps->Count(); i++ ) + { + iAvailableIaps->AddIap( iActiveIaps->IapL( i ) ); + } + + TInt iapCount = iAvailableIaps->Count(); + TBool gprsSelected( EFalse ); + + if( cmCount ) + { + IPTVLOGSTRING3_LOW_LEVEL("CIptvNetworkSelection:: %d %d", cmCount, iapCount ); + TInt t=0; + while( tIapL( s ).iId ) + { + // Found usable wlan, select + bestIap = alrIap; + s = iapCount; + t = cmCount; + } + s++; + } + } + t++; + } + } + + // Check if wlan available when gprs already selected + if( !iOffline ) + { + + if( gprsSelected ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: check if WLAN available" ); + // GPRS selected, check if WLAN available in other SNAPs + + // Get list of connection methods that do not belong to any destination + RArray iapArray( 3 ); + manager.ConnectionMethodL( iapArray ); + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: not any dest: %d", iapArray.Count() ); + + TInt checkedId( 0 ); + for( TInt t=0; tIapL( s ).iId ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvNetworkSelection:: iWlanWhenGPRS = ETrue" ); + iWlanWhenGPRS = ETrue; + s = iapCount; + } + s++; + } + + } + CleanupStack::PopAndDestroy( &cm ); + } + + if( !iWlanWhenGPRS ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: Still not found WLAN" ); + // Still not found WLAN, check other snaps + RArray destArray(3); + manager.AllDestinationsL( destArray ); + + TInt selectedDest( 0 ); + CRepository* cenRep = CRepository::NewLC( KIptvAlrCenRepUid ); + cenRep->Get( KIptvCenRepUsedSnapIdKey, selectedDest ); + CleanupStack::PopAndDestroy( cenRep ); + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: dest count:%d", destArray.Count() ); + + for( TInt s=0; sIapL( s ).iId ) + { + IPTVLOGSTRING_LOW_LEVEL(" CIptvNetworkSelection:: iWlanWhenGPRS = ETrue" ); + iWlanWhenGPRS = ETrue; + s = iapCount; + } + s++; + } + } + } + CleanupStack::PopAndDestroy( &cmDest ); + } + } + + } + } + } + +#endif // __WINSCW__ + + CleanupStack::PopAndDestroy( &cmDest ); + CleanupStack::PopAndDestroy( &manager ); + + if( bestIap ) + { + SelectL( aGetUsedIapReq, bestIap ); + } + else + { + aGetUsedIapReq.iRespStatus = static_cast(ENoSuitableIapFound); + } + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetUsedIapAfterWlanScanL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::SetConnectionAllowed +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::SetConnectionAllowedL(TBool aConnectionAllowed, + TUint32 aIapId, + TRespStatus& aRespStatus) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::SetConnectionAllowedL() start"); + + if ( aConnectionAllowed ) + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: setting connection allowed for: %S type", + &(ConnectionTypeDes( CIptvUtil::ConnectionTypeL( aIapId ) ) )); + + iConnectionAllowedMask |= CIptvUtil::ConnectionTypeL( aIapId ); + + } + else + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: clearing connection allowed for: %S type", + &(ConnectionTypeDes( CIptvUtil::ConnectionTypeL( aIapId ) ) )); + + iConnectionAllowedMask &= ~CIptvUtil::ConnectionTypeL(aIapId); + } + + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: connection allowed mask is now: %x", iConnectionAllowedMask); + + aRespStatus = ESucceeded; + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::SetConnectionAllowedL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::GetIapNameL +// Gets IAP name, if empty, tries to find SSID +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::GetIapNameL( TUint32 aIapId, TDes& aIapName ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetIapNameL() start"); + + TInt leaveValue = KErrNotFound; + + aIapName.Zero(); + + CCommsDatabase* commsDb = CCommsDatabase::NewL( EDatabaseTypeUnspecified ); + CleanupStack::PushL( commsDb ); //1-> + + CCommsDbTableView* iapTableView; + + //get iap table view + iapTableView = commsDb->OpenTableLC( TPtrC(IAP) ); //2-> + + //Search correct iap and pick connection name + TInt err = iapTableView->GotoFirstRecord(); + + while ( err == KErrNone ) + { + TUint32 iapId; + iapTableView->ReadUintL( TPtrC(COMMDB_ID), iapId ); + + if ( aIapId == iapId ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: IAP found."); + + TUint32 iapService; + + iapTableView->ReadTextL( TPtrC(COMMDB_NAME), aIapName ); + //IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: COMMDB_NAME: %S", &aIapName); + + iapTableView->ReadUintL( TPtrC(IAP_SERVICE), iapService ); + //IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: IAP_SERVICE = %d", iapService); + + //Try to get SSID if IAP had no name + if ( aIapName.Length() == 0 ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: IAP name was empty, trying to get SSID"); + + TBuf colText; + iapTableView->ReadTextL( TPtrC(IAP_SERVICE_TYPE), colText ); + if ( colText == KIptvUtilLanService ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: was lan service, proceeding"); + + TInt err = GetSsidL( iapService, aIapName ); + if ( err == KErrNone ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: SSID id found, returning it"); + leaveValue = KErrNone; + } + else + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: Could not get SSID, wasn't WLAN service"); + } + } + else + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: was not lan service, can't be wlan service."); + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: giving up."); + } + } + else + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: IAP name found, returning it"); + leaveValue = KErrNone; + } + + break; + } + err = iapTableView->GotoNextRecord(); + } + CleanupStack::PopAndDestroy( iapTableView ); //<-2 + CleanupStack::PopAndDestroy( commsDb ); //<-1 + + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetIapNameL() exit"); + User::LeaveIfError( leaveValue ); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::GetIapIdL +// Gets IAP ID +// ----------------------------------------------------------------------------- +// +TInt CIptvNetworkSelection::GetIapIdL(TUint32& aIapId, const TDesC& aIapName) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetIapIdL() start"); + + TInt returnValue = KErrNotFound; + + CCommsDatabase* commsDb = CCommsDatabase::NewL(EDatabaseTypeUnspecified); + CleanupStack::PushL(commsDb); //1-> + + CCommsDbTableView* iapTableView; + + //get iap table view + iapTableView = commsDb->OpenTableLC(TPtrC(IAP)); //2-> + + //Search correct iap name and pick iap id + TInt err = iapTableView->GotoFirstRecord(); + + while ( err == KErrNone ) + { + TBuf iapName; + + iapTableView->ReadTextL(TPtrC(COMMDB_NAME), iapName); + + if ( aIapName == iapName ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: IAP found."); + + iapTableView->ReadUintL(TPtrC(COMMDB_ID), aIapId); + //IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: COMMDB_ID: %d", aIapId); + + returnValue = KErrNone; + break; + } + err = iapTableView->GotoNextRecord(); + } + CleanupStack::PopAndDestroy(iapTableView); //<-2 + CleanupStack::PopAndDestroy(commsDb); //<-1 + + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetIapIdL() exit"); + return returnValue; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::GetSsidL +// ----------------------------------------------------------------------------- +// +TInt CIptvNetworkSelection::GetSsidL( TUint32 aWlanServiceId, TDes& aSsid ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetSsidL() start"); + + TInt returnValue = KErrNotFound; + + CCommsDatabase* commsDb = CCommsDatabase::NewL(EDatabaseTypeUnspecified); + CleanupStack::PushL(commsDb); //1-> + + CCommsDbTableView* wlanTableView; + + //get wlan table view + wlanTableView = commsDb->OpenTableLC(TPtrC(WLAN_SERVICE));//2-> + + TUint32 wlanServiceId; + TInt err = wlanTableView->GotoFirstRecord(); + TBuf ssid; + + while(err == KErrNone) + { + wlanTableView->ReadUintL(TPtrC(WLAN_SERVICE_ID), wlanServiceId); + + +#if 1 // def __SERIES60_32__ + wlanTableView->ReadTextL(TPtrC(NU_WLAN_SSID), ssid); +#else + wlanTableView->ReadTextL(TPtrC(WLAN_SSID), ssid); +#endif // __SERIES60_32__ + + if(wlanServiceId == aWlanServiceId) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: WLAN service ID found, returning SSID"); + aSsid = ssid; + returnValue = KErrNone; + break; + } + err = wlanTableView->GotoNextRecord(); + } + CleanupStack::PopAndDestroy(wlanTableView); // <-2 + CleanupStack::PopAndDestroy(commsDb); // <-1 + + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetSsidL() exit"); + return returnValue; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::GetActiveIapsL +// ----------------------------------------------------------------------------- +// +CIptvIapList* CIptvNetworkSelection::GetActiveIapsL() + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetActiveIaps() start"); + + CIptvIapList* iapList; + iapList = CIptvIapList::NewL(); + CleanupStack::PushL(iapList); // 1-> + + TUint count; + RSocketServ serv; + RConnection connection; + + + if ( serv.Connect() == KErrNone ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: socket server open"); + if ( connection.Open(serv, KAfInet ) == KErrNone) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: connection open"); + if ( connection.EnumerateConnections( count ) == KErrNone ) + { + //IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: connection count: %d", count); + for (; count; --count ) + { + TPckgBuf connInfo; + + if ( connection.GetConnectionInfo( count, connInfo ) == KErrNone ) + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: connection: %d", count); + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: IapId: %d", connInfo().iIapId); + TIptvIap iap; + iap.iId = connInfo().iIapId; + iap.iPriority = 0; + if ( iapList->AddIap( iap, ETrue ) != KErrNone ) + { + IPTVLOGSTRING_HIGH_LEVEL("CIptvNetworkSelection:: IAP list overflow, could not add all active IAPS!"); + } + } + } + } + connection.Close(); + } + serv.Close(); + } + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetActiveIaps() exit"); + + CleanupStack::Pop(iapList); // <-1 + return iapList; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateActiveIapsL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateActiveIapsL() + { + if ( iActiveIaps ) + { + delete iActiveIaps; + iActiveIaps = NULL; + } + + iActiveIaps = GetActiveIapsL(); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateWlanScannedIapsL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateWlanScannedIapsL() + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateWlanScannedIapsL() start"); + + User::LeaveIfError( iConnMon.ConnectL() ); + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: iConnMon connected"); + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: starting async wlan scan"); + + iConnMon.GetPckgAttribute( EBearerIdWLAN, + 0, + KIapAvailability, + iIapInfoBuf, + iStatus ); + + SetActive(); + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateWlanScannedIapsL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::RunL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::RunL() + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::RunL() start"); + + delete iScannedWlanIaps; + iScannedWlanIaps = NULL; + iScannedWlanIaps = CIptvIapList::NewL(); + + if ( iStatus.Int() != KErrNone ) + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: wlan scan failed. iStatus: %d", iStatus.Int() ); + } + else + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: wlan scan successful."); + + TConnMonIapInfo iapInfo = iIapInfoBuf(); + TInt i; + for ( i = 0; i < iapInfo.iCount; i++ ) + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: wlan iap: %d", iapInfo.iIap[i].iIapId); + TIptvIap iap; + iap.iId = iapInfo.iIap[i].iIapId; + iap.iPriority = 0; + iap.iValueExists = ETrue; + iScannedWlanIaps->AddIap( iap, ETrue /* ignore max limit */ ); + } + } + + iConnMon.Close(); + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: Scanned WLAN IAPs:"); +#if IPTV_LOGGING_METHOD != 0 + PrintIapList( *iScannedWlanIaps ); +#endif + + //wlan scan has been performed (successfully or not) + //Now handle all GetUsedIapReq:s we have pending + HandleGetUsedIapRequests(); + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::RunL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::RunError +// ----------------------------------------------------------------------------- +// +TInt CIptvNetworkSelection::RunError( TInt /*aError*/ ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::RunError() leave in RunL!"); + + iConnMon.Close(); + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::FindCommonIapFromListsL +// ----------------------------------------------------------------------------- +// +TInt CIptvNetworkSelection::FindCommonIapFromListsL( CIptvIapList& aServiceIaps, + CIptvIapList& aCompareIaps, + TIptvIap& aIap ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::FindCommonIapFromListsL() start"); + + aServiceIaps.SortByPriorityL(); + + TInt i, j; + for ( j = 0; j < aServiceIaps.Count(); j++ ) + { + //IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: service iap = %d", aServiceIaps.IapL(j).iId); + for ( i = 0; i < aCompareIaps.Count(); i++ ) + { + //IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: compare iap = %d", aCompareIaps.IapL(i).iId); + + if ( aServiceIaps.IapL(j).iId == aCompareIaps.IapL(i).iId ) + { + //IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: common IAP found from service and compare lists: %d", aServiceIaps.IapL(j).iId); + aIap.iValueExists = ETrue; + aIap.iId = aServiceIaps.IapL(j).iId; + aIap.iPriority = aServiceIaps.IapL(j).iPriority; + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::FindCommonIapFromListsL() exit"); + return KErrNone; + } + } + + } + + aIap.iValueExists = EFalse; + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: common IAP not found from service and compare lists"); + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::FindCommonIapFromListsL() exit"); + return KErrNotFound; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::IsConnectionAllowedL +// ----------------------------------------------------------------------------- +// +CIptvNetworkSelection::TConnectionPermission CIptvNetworkSelection::IsConnectionAllowedL( + TUint32 aIapId ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::IsConnectionAllowed() start"); + + TConnectionPermission connectionPermission; + CIptvUtil::TConnectionType connectionType; + + connectionType = CIptvUtil::ConnectionTypeL( aIapId ); + +#if IPTV_LOGGING_METHOD != 0 + const TInt KMaxIapNameLength = 255; + TBuf iapName; + TRAP_IGNORE( GetIapNameL( aIapId, iapName ) ); //dont leave from debug code + + IPTVLOGSTRING3_LOW_LEVEL("CIptvNetworkSelection:: IAP Name = %S, connection type = %S", + &iapName, + &ConnectionTypeDes( connectionType )); +#endif + + if ( connectionType & iConnectionAllowedMask ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: Connection is allowed"); + connectionPermission = EAllowed; + } + else + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: Connection is not allowed"); + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: ->EMustAskConfirmation"); + connectionPermission = EMustAskConfirmation; + } + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::IsConnectionAllowed() exit"); + return connectionPermission; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::CreateFilteredIapListL +// ----------------------------------------------------------------------------- +// +CIptvIapList* CIptvNetworkSelection::CreateFilteredIapListL(CIptvIapList& aIapList, + TUint32 aConnectionTypeMask) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::CreateFilteredIapListL() start"); + + CIptvIapList* filteredIapList = CIptvIapList::NewL(); + CleanupStack::PushL( filteredIapList ); // 1-> + + TInt i; + for ( i = 0; i < aIapList.Count(); i++ ) + { + if((CIptvUtil::ConnectionTypeL( aIapList.IapL(i).iId ) & aConnectionTypeMask)) + { + //IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: Adding %d to filtered iap list.", aIapList.IapL(i).iId); + filteredIapList->AddIap( aIapList.IapL( i ), ETrue ); + } + } + CleanupStack::Pop( filteredIapList ); // <-1 + + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::CreateFilteredIapListL() exit"); + return filteredIapList; + } + +#ifdef ISIAIMATCH_USED +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateSiAiMatchL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateSiAiMatchL() + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateSiAiMatchL() start"); + + if ( iService && iActiveIaps ) + { + TInt err = FindCommonIapFromListsL(*(iService->iIapList), + *iActiveIaps, + iSiAiMatch); + } + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateSiAiMatchL() exit"); + } +#endif + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateSiSwiMatchL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateSiSwiMatchL() + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateSiSwiMatchL() start"); + + if ( iService && iScannedWlanIaps ) + { + TInt err = FindCommonIapFromListsL(*(iService->iIapList), + *iScannedWlanIaps, + iSiSwiMatch); + } + + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateSiSwiMatchL() exit"); + } + +#ifdef ICISIMATCH_USED +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateCiSiMatch +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateCiSiMatch() + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateCiSiMatch() start"); + + TUint8 iapIndex; + + if ( !iCurrentIap.iValueExists ) + { + iCiSiMatch.iValueExists = EFalse; + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateCiSiMatch() exit"); + return; + } + TInt err( KErrNotReady ); + if ( iService && iService->iIapList ) + { + err = iService->iIapList->FindIap(iCurrentIap.iId, iapIndex); + } + + if ( err == KErrNone ) + { + iCiSiMatch.iValueExists = ETrue; + TRAP_IGNORE( //iapIndex is valid since FindIap didnt return error, we can ignore leave + iCiSiMatch.iId = iService->iIapList->IapL( iapIndex ).iId; + iCiSiMatch.iPriority = iService->iIapList->IapL( iapIndex ).iPriority; + ); + } + else + { + iCiSiMatch.iValueExists = EFalse; + } + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateCiSiMatch() exit"); + } +#endif + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateCiAiMatch +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateCiAiMatch() + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateCiAiMatch() start"); + + TUint8 iapIndex; + + if ( !iCurrentIap.iValueExists ) + { + iCiAiMatch.iValueExists = EFalse; + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateCiAiMatch() exit"); + return; + } + + TInt err = iActiveIaps->FindIap(iCurrentIap.iId, iapIndex); + + if ( err == KErrNone ) + { + iCiAiMatch.iValueExists = ETrue; + TRAP_IGNORE( //iapIndex is valid, we can ignore leave + iCiAiMatch.iId = iActiveIaps->IapL(iapIndex).iId; + iCiAiMatch.iPriority = iActiveIaps->IapL(iapIndex).iPriority; //this is not valid + ); + } + else + { + iCiAiMatch.iValueExists = EFalse; + } + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateCiAiMatch() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateCiSwiMatchL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateCiSwiMatchL() + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateCiSwiMatchL() start"); + + TUint8 iapIndex; + + if ( !iCurrentIap.iValueExists ) + { + iCiSwiMatch.iValueExists = EFalse; + return; + } + TInt err( KErrNotReady ); + if ( iScannedWlanIaps ) + { + err = iScannedWlanIaps->FindIap( iCurrentIap.iId, iapIndex ); + } + + if ( err == KErrNone ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: CiSwiMatch found."); + iCiSwiMatch.iValueExists = ETrue; + iCiSwiMatch.iId = iCurrentIap.iId; + iCiSwiMatch.iPriority = iCurrentIap.iPriority; + } + else + { + TBool isHiddenWlanIap = EFalse; + CIptvUtil::TConnectionType connType; + + connType = CIptvUtil::ConnectionTypeL( iCurrentIap.iId, isHiddenWlanIap ); + + if ( connType == CIptvUtil::EWlan && isHiddenWlanIap && iOffline ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: Current IAP was hidden wlan iap and we were in offline mode, setting to CiSwiMatch"); + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: even if it is not on scanned wlan iaps list."); + iCiSwiMatch.iValueExists = ETrue; + iCiSwiMatch.iId = iCurrentIap.iId; + iCiSwiMatch.iPriority = iCurrentIap.iPriority; + } + else + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: CiSwiMatch not found."); + iCiSwiMatch.iValueExists = EFalse; + } + } + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateCiSwiMatchL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::DoCancel +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::DoCancel() + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::DoCancel() active object cancelled!"); + + iConnMon.CancelAsyncRequest( EConnMonGetPckgAttribute ); // From TConnMonAsyncRequest + iConnMon.Close(); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::TimerExpired +// ----------------------------------------------------------------------------- +// +#ifdef __WINSCW__ +void CIptvNetworkSelection::TimerExpired(CIptvTimer* aTimer) +#else +void CIptvNetworkSelection::TimerExpired(CIptvTimer* /*aTimer*/) +#endif + { +#ifdef __WINSCW__ + + if ( aTimer == iWlanScanSimulationTimer ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: iWlanScanSimulationTimer expired"); + HandleGetUsedIapRequests(); + return; + } + +#endif + + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::GetWlanIapFromAiL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::GetWlanIapFromAiL(TIptvIap& aIap) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetWlanIapFromAiL() start"); + + aIap.iValueExists = EFalse; + + TInt i; + for ( i = 0; i < iActiveIaps->Count(); i++ ) + { + if ( CIptvUtil::ConnectionTypeL( iActiveIaps->IapL( i ).iId ) == CIptvUtil::EWlan ) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: WLAN IAP found from Ai"); + aIap.iValueExists = ETrue; + aIap.iId = iActiveIaps->IapL( i ).iId; + aIap.iPriority = iActiveIaps->IapL( i ).iPriority; + return; //there can be only one wlan iap in Ai, no need to go further + } + } + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetWlanIapFromAiL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::SelectCiL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::SelectCiL(TIptvGetUsedIapReq& aGetUsedIapReq) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: Selected iCurrentIap"); + SelectL(aGetUsedIapReq, iCurrentIap.iId); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::SelectL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::SelectL(TIptvGetUsedIapReq& aGetUsedIapReq, TUint32 aIapId) + { + aGetUsedIapReq.iIapId = aIapId; + aGetUsedIapReq.iWLANWhenGPRS = iWlanWhenGPRS; + + TRAPD( err, GetIapNameL(aGetUsedIapReq.iIapId, aGetUsedIapReq.iIapName)); + + // If other than KErrNoMemory error occurs, we just give empty iap name and ignore leave + if ( err != KErrNone ) + { + if (err == KErrNoMemory ) + { + User::Leave( KErrNoMemory ); + } + else + { + aGetUsedIapReq.iIapName.Zero(); + } + } + + aGetUsedIapReq.iConnectionPermission = static_cast( IsConnectionAllowedL( + aGetUsedIapReq.iIapId ) ); + aGetUsedIapReq.iRespStatus = static_cast( ESucceeded ); + + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: Selected IAP ID: %d", aIapId); + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: Selected IAP name: %S", &(aGetUsedIapReq.iIapName)); + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: Selected conn perm: %d", aGetUsedIapReq.iConnectionPermission); + IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: Selected resp status: %d", aGetUsedIapReq.iRespStatus); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateAllButWlanListsL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateAllButWlanListsL(TIptvGetUsedIapReq& /*aGetUsedIapReq*/) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateAllButWlanListsL() start"); + + if ( iOffline ) + { + ClearGprsAndCsdIapsL(); + } + + UpdateActiveIapsL(); + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateAllButWlanListsL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::UpdateServiceL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::UpdateServiceL(TUint32 aServiceId) + { + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateServiceL() start"); + + delete iService; + iService = NULL; + + iService = iServer.iServiceManager->GetServiceL( aServiceId, ETrue /* do open/close */ ); + if ( iService ) + { + iService->iIapList->SortByPriorityL(); + + //convert iap name (if exists) to iap id + if ( iService->GetIapNameL().Length() > 0 ) + { + TUint32 iapId; + TInt err = GetIapIdL(iapId, iService->GetIapNameL()); + TIptvIap iap; + iap.iId = iapId; + iap.iPriority = 0; + iap.iValueExists = ETrue; + iService->GetIapList().AddIap(iap); + IPTVLOGSTRING3_LOW_LEVEL("CIptvNetworkSelection:: Converted %S iap name to iap id: %d", &(iService->GetIapNameL()), iapId); + iService->SetIapNameL(KIptvEmptyDes); + iServer.iServiceManager->UpdateServiceL(*iService); + } + } + + //IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::UpdateServiceL() exit"); + } + +#if IPTV_LOGGING_METHOD != 0 +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::PrintIapList +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::PrintIapList( CIptvIapList& aIapList ) + { + TUint8 i; + + if ( aIapList.Count() == 0 ) + { + IPTVLOGSTRING_HIGH_LEVEL("CIptvNetworkSelection:: * Iaplist empty. *"); + return; + } + + const TInt KMaxIapNameLength = 255; + TBuf iapName; + TUint32 iapId; + TUint16 iapPriority; + for ( i = 0; i < aIapList.Count(); i++ ) + { + TRAPD( err, GetIapNameL( aIapList.IapL(i).iId, iapName )); + if ( err != KErrNone ) + { + iapName.Zero(); + } + + TRAP( err, iapId = aIapList.IapL(i).iId ); + if ( err != KErrNone ) + { + iapId = KMaxTUint32; + } + + TRAP( err, iapPriority = aIapList.IapL(i).iPriority ); + if ( err != KErrNone ) + { + iapPriority = KMaxTUint16; + } + + IPTVLOGSTRING4_HIGH_LEVEL( + "CIptvNetworkSelection:: * IAP Name: %S, ID %d PRIO: %d *", + &iapName, iapId, iapPriority ); + } + } +#endif + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::ClearUsedIap +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::ClearUsedIap() + { + IPTVLOGSTRING_HIGH_LEVEL("CIptvNetworkSelection:: current iap cleared."); + iCurrentIap.iValueExists = EFalse; + iCurrentIap.iId = 0; + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::AddHiddenWlanSiIapsToSwiL +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::AddHiddenWlanSiIapsToSwiL() + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::AddHiddenWlanSiIapsToSwiL() start"); + + TInt i; + for ( i = 0; i < iService->iIapList->Count(); i++ ) + { + TIptvIap& iap = iService->iIapList->IapL( i ); + TBool isHiddenWlanIap; + CIptvUtil::TConnectionType connType; + + connType = CIptvUtil::ConnectionTypeL( iap.iId, isHiddenWlanIap ); + + if ( connType == CIptvUtil::EWlan && isHiddenWlanIap ) + { + IPTVLOGSTRING2_HIGH_LEVEL("CIptvNetworkSelection:: adding hidden service IAP (%d) to scanned wlan iaps list", iap.iId); + if ( iScannedWlanIaps ) + { + TInt err = iScannedWlanIaps->AddIap(iap, ETrue /* ignore max limit */); + if ( err != KErrNone ) + { + IPTVLOGSTRING2_LOW_LEVEL( "CIptvNetworkSelection::AddHiddenWlanSiIapsToSwiL: iScannedWlanIaps->AddIap failed: %d", err ); + } + } + } + } + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::AddHiddenWlanSiIapsToSwiL() exit"); + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::HandleActiveProfileEventL() +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::HandleActiveProfileEventL( TProfileEvent aProfileEvent, + TInt aProfileId ) + { + if ( aProfileEvent == EProfileNewActiveProfile ) //active profile has been changed + { + if ( aProfileId == EProfileOffLineId ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: phone changed to offline mode"); + iOffline = ETrue; + } + else + { + if (iOffline) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: phone changed back to online mode."); + iOffline = EFalse; + } + } + } + } + +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::ClearGprsAndCsdIaps() +// ----------------------------------------------------------------------------- +// +void CIptvNetworkSelection::ClearGprsAndCsdIapsL() + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::ClearGprsAndCsdIaps() start"); + + //Clear iCurrentIap if it is EGprs or ECsd + if ( iCurrentIap.iValueExists ) + { + if ( CIptvUtil::ConnectionTypeL( iCurrentIap.iId ) == CIptvUtil::EGprs || + CIptvUtil::ConnectionTypeL( iCurrentIap.iId ) == CIptvUtil::ECsd ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: iCurrentIap (GPRS/CSD type) cleared"); + iCurrentIap.iValueExists = EFalse; + } + } + + //Clear EGprs and ECsd iaps from iService iaps + CIptvIapList* serviceIaps = CreateFilteredIapListL( iService->GetIapList(), CIptvUtil::EWlan ); + CleanupStack::PushL( serviceIaps ); // 1-> + iService->SetIapListL( *serviceIaps ); + CleanupStack::PopAndDestroy( serviceIaps ); // <-1 + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: iService GPRS and CSD IAPS cleared"); + + IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::ClearGprsAndCsdIaps() exit"); + } + +#if IPTV_LOGGING_METHOD != 0 +// ----------------------------------------------------------------------------- +// CIptvNetworkSelection::ConnectionTypeDes() +// ----------------------------------------------------------------------------- +// +const TDesC& CIptvNetworkSelection::ConnectionTypeDes( CIptvUtil::TConnectionType aConnectionType ) + { + switch ( aConnectionType ) + { + case CIptvUtil::EWlan: + return KIptvNsWlan; + + case CIptvUtil::EGprs: + return KIptvNsGprs; + + case CIptvUtil::ECsd: + return KIptvNsCsd; + + default: + return KIptvNsUnknown; + } + } +#endif