--- /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 <cdbcols.h>
+#include <WlanCdbCols.h>
+#include "IptvDebug.h"
+#include <commdb.h>
+#include <bldvariant.hrh>
+
+#include <es_enum.h> //TConnectionInfo
+#include <in_sock.h>
+#include <rconnmon.h>
+#include <wlanmgmtcommon.h>
+
+#include <CProfileChangeNotifyHandler.h>
+#include <Profile.hrh>
+
+#include <MProfileEngine.h>
+
+#include <cmdestinationext.h>
+#include <cmmanagerext.h>
+#include <centralrepository.h>
+#include <cmpluginwlandef.h>
+
+// 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<TUint8>( ENoSuitableIapFound );
+ invalidDest = ETrue;
+ }
+ else if ( destId == KIptvCenRepAPModeAlwaysAsk )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * KIptvCenRepUsedSnapIdKey always ask");
+ aGetUsedIapReq->iRespStatus = static_cast<TUint8>( 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<TUint8>(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<TUint8>(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<TUint8>(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<TUint8>(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( t<cmCount )
+ {
+ RCmConnectionMethodExt connMethod = cmDest.ConnectionMethodL( t );
+ CleanupClosePushL( connMethod );
+ alrIap = connMethod.GetIntAttributeL( CMManager::ECmIapId );
+ bearerType = connMethod.GetIntAttributeL( CMManager::ECmBearerType );
+ CleanupStack::PopAndDestroy( &connMethod );
+ if( !iOffline && ( KUidWlanBearerType != bearerType ) )
+ {
+ // Found gprs, select
+ bestIap = alrIap;
+ gprsSelected = ETrue;
+ t = cmCount;
+ }
+ else
+ {
+ TInt s=0;
+ while( s<iapCount )
+ {
+ if( alrIap == iAvailableIaps->IapL( 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<TUint32> iapArray( 3 );
+ manager.ConnectionMethodL( iapArray );
+ IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: not any dest: %d", iapArray.Count() );
+
+ TInt checkedId( 0 );
+ for( TInt t=0; t<iapArray.Count(); t++ )
+ {
+ // Check if WLAN iap found
+ RCmConnectionMethodExt cm = manager.ConnectionMethodL( iapArray[t] );
+ CleanupClosePushL( cm );
+ if( cm.GetIntAttributeL( CMManager::ECmBearerType ) == KUidWlanBearerType )
+ {
+ checkedId = cm.GetIntAttributeL( CMManager::ECmIapId );
+ TInt s=0;
+ while( s < iapCount )
+ {
+ if( checkedId == iAvailableIaps->IapL( 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<TUint32> 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; s<destArray.Count(); s++ )
+ {
+ // Check all other destinations all iaps
+ if( selectedDest != destArray[s] )
+ {
+ RCmDestinationExt cmDest = manager.DestinationL( destArray[s] );
+ CleanupClosePushL( cmDest );
+ TInt methodCount = cmDest.ConnectionMethodCount();
+
+ IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: methodCoun:%d", methodCount );
+
+ for( TInt t=0; t<methodCount; t++ )
+ {
+ RCmConnectionMethodExt cm = cmDest.ConnectionMethodL( t );
+ if( cm.GetIntAttributeL( CMManager::ECmBearerType ) == KUidWlanBearerType )
+ {
+ checkedId = cm.GetIntAttributeL( CMManager::ECmIapId );
+ TInt s=0;
+ while( s < iapCount )
+ {
+ if( checkedId == iAvailableIaps->IapL( 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<TUint8>(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<KIptvUtilMaxTextFieldLengthInDb> 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<KIptvUtilMaxTextFieldLengthInDb> 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<KWlanMaxSsidLength> 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<TConnectionInfo> 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<KMaxIapNameLength> 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<TUint8>( IsConnectionAllowedL(
+ aGetUsedIapReq.iIapId ) );
+ aGetUsedIapReq.iRespStatus = static_cast<TUint8>( 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<KMaxIapNameLength> 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