FCL/sf/os/wlan: comparison wlan_bearer/wlanengine/wlan_symbian/wlanengine_symbian

equal deleted inserted replaced

-:af3fb27c7511
+:13838cf40350
 * Description:  Server class of wlan engine
 *
 */
 /*
-* %version: 105.1.1 %
+* %version: 105.1.3 %
 */
 #include <e32def.h>
 #include <e32std.h>
 #include <featmgr.h>
 }
 core_mac_address_s core_mac( ZERO_MAC_ADDR );
 TWlanConversionUtil::ConvertMacAddress( core_mac, mac );
 // Get Device Settings
-CWlanDeviceSettings::SWlanDeviceSettings deviceSettings;
+GetWlanSettingsL( iDeviceSettings );
-GetWlanSettingsL( deviceSettings );
+SetCachedRegion(iDeviceSettings.region, iDeviceSettings.regionTimestamp);
-SetCachedRegion(deviceSettings.region, deviceSettings.regionTimestamp);
 core_device_settings_s coreSettings; // core needs the settings here
-TWlanConversionUtil::ConvertDeviceSettings( coreSettings, deviceSettings );
+TWlanConversionUtil::ConvertDeviceSettings( coreSettings, iDeviceSettings );
 // Create core server
 User::LeaveIfNull( iCoreServer = core_server_factory_c::instance(
 *this,
 *iDriverIf,
 coreSettings,
 core_mac,
 TWlanConversionUtil::ConvertFeatureFlags(
 iSupportedFeatures,
-deviceSettings.enabledFeatures ) ) );
+iDeviceSettings.enabledFeatures ) ) );
 iCoreServer->disable_wlan( KWlanIntCmdDisableWlan );
 // Create scan timer
 DEBUG( "CWlmServer::ConstructL() - create backgroundscan timer" );
 TCallBack expiredCb( ScanSchedulingTimerExpired, this );
 canceledCb,
 emptyCb );
 // Create scan cache
 iCache = CWlanScanResultCache::NewL();
-iConfiguredCacheLifetime = deviceSettings.scanExpirationTimer;
+iConfiguredCacheLifetime = iDeviceSettings.scanExpirationTimer;
 // Create a callback for asynchronous core requests
 TCallBack callback( HandleCoreAsynchCb, this );
 iCoreAsynchCb = new (ELeave) CAsyncCallBack(
 callback, CActive::EPriorityStandard );
 }
 // Stop all plugins
 iGenericWlanPlugin.StopPlugins();
+iIapWeakList.Close();
 delete iCoreServer;
 delete iDriverIf;
 iNotificationArray.Close();
 delete iCache;
 delete iPlatform;
 *connectionStatus = core_connect_undefined;
 TInt ret = GetCurrentIapId(
 static_cast<TUint>(lanServiceId),
 *coreIapData );
+iConnectionIapId = coreIapData->iap_id;
 if (  ret != KErrNone )
 {
 secondarySsidList.Close();
 delete coreIapData;
 delete coreSsidList;
 DEBUG( "CWlmServer::GetAvailableIaps()" );
 // Read cacheLifetime and maxDelay arguments
 TPckgBuf<TInt> cacheLifetimePckg( KWlmDefaultScanCacheLifetime );
 TPckgBuf<TUint> maxDelayPckg( 0 );
+TBool isFiltered(
+aMessage.Int3() );
+DEBUG1( "CWlmServer::GetAvailableIaps() - isFiltered: %u",
+isFiltered );
 if( aMessage.Read( 1, cacheLifetimePckg ) != KErrNone )
 {
 DEBUG( "CWlmServer::GetAvailableIaps() - unable to read lifetime parameter" );
 aMessage.Complete( KErrArgument );
 /**
 * See if cached IAP availability information is available.
 */
 RArray<TWlanLimitedIapData> iapList;
-RArray<TUint>* list = iCache->AvailableIaps(
+RArray<TWlmAvailabilityData>* list = iCache->AvailableIaps(
 iapList,
 ( cacheLifetimePckg() == 0 ? 1 : cacheLifetimePckg() ) );
 // Only complete with valid cache if maxDelay is zero
 if( list && maxDelayPckg() == 0 )
 {
+TWlmAvailableIaps tmp = { 0 };
-TWlmAvailableIaps tmp;
+if( isFiltered )
-const TInt listCount(
+{
-Min( list->Count(), KWlmMaxAvailableIaps ) );
+DEBUG1( "CWlmServer::GetAvailableIaps() - using filtered cached IAP list, list contains %d IAP(s)",
+list->Count() );
-DEBUG1( "CWlmServer::GetAvailableIaps() - using cached IAP list, list contains %d IAP(s)", listCount );
+for( TInt idx( 0 ); idx < list->Count() && tmp.count < KWlmMaxAvailableIaps; ++idx )
-TInt listIdx( 0 );
+{
+if( (*list)[idx].rcpi >= iDeviceSettings.minRcpiForIapAvailability &&
-while( listIdx < listCount )
+iIapWeakList.Find( (*list)[idx].iapId ) == KErrNotFound )
 {
-tmp.iaps[ listIdx ] = (*list)[listIdx];
+DEBUG2( "CWlmServer::GetAvailableIaps() - IAP %u is available, RCPI is %u",
-++listIdx;
+(*list)[idx].iapId, (*list)[idx].rcpi );
-}
+tmp.iaps[tmp.count++] = (*list)[idx];
-tmp.count = listCount;
+}
+else
+{
+DEBUG2( "CWlmServer::GetAvailableIaps() - IAP %u filtered, RCPI is %u",
+(*list)[idx].iapId, (*list)[idx].rcpi );
+}
+}
+}
+else
+{
+DEBUG1( "CWlmServer::GetAvailableIaps() - using cached IAP list, list contains %d IAP(s)",
+list->Count() );
+for( TInt idx( 0 ); idx < list->Count() && tmp.count < KWlmMaxAvailableIaps; ++idx )
+{
+DEBUG2( "CWlmServer::GetAvailableIaps() - IAP %u is available, RCPI is %u",
+(*list)[idx].iapId, (*list)[idx].rcpi );
+tmp.iaps[tmp.count++] = (*list)[idx];
+}
+}
 TPckg<TWlmAvailableIaps> outPckg( tmp );
 aMessage.Write( 0, outPckg );
 aMessage.Complete( KErrNone );
 iapList.Close();
 }
 iapList.Close();
 // Create output list
-core_type_list_c<u32_t>* iapIdList = new core_type_list_c<u32_t>;
+core_type_list_c<core_iap_availability_data_s>* iapAvailabilityList =
-if( iapIdList == NULL )
+new core_type_list_c<core_iap_availability_data_s>;
+if( iapAvailabilityList == NULL )
 {
 aMessage.Complete( KErrNoMemory );
 delete iapDataList;
 delete iapSsidList;
 return;
 if( scanList == NULL )
 {
 aMessage.Complete( KErrNoMemory );
 delete iapDataList;
 delete iapSsidList;
-delete iapIdList;
+delete iapAvailabilityList;
 return;
 }
 TUint* scanTime( NULL );
 if( maxDelayPckg() != KWlmInfiniteScanDelay )
 DEBUG( "CWlmServer::GetAvailableIaps() - unable to instantiate TUint" );
 aMessage.Complete( KErrNoMemory );
 delete iapDataList;
 delete iapSsidList;
-delete iapIdList;
+delete iapAvailabilityList;
 delete scanList;
 return;
 }
 }
 mapEntry.iMessage = aMessage;
 mapEntry.iFunction = EGetAvailableIaps;
 mapEntry.iRequestId = iRequestIdCounter++;
 mapEntry.iSessionId = aSessionId;
 mapEntry.iParam0 = iapDataList;
-mapEntry.iParam1 = iapIdList;
+mapEntry.iParam1 = iapAvailabilityList;
 mapEntry.iParam2 = scanList;
 mapEntry.iParam3 = iapSsidList;
+mapEntry.iParam4 = reinterpret_cast<TAny*>( isFiltered );
 mapEntry.iTime = scanTime;
 iRequestMap.Append( mapEntry );
 // Scan scheduling timer needs to be set again if this request needs the results earlier or
 // if this is the only timed pending request
 {
 DEBUG1( "CWlmServer::UpdateWlanSettings() - GetWlanSettingsL leaved with code %d", err );
 return err;
 }
+iDeviceSettings = settings;
 // Only if startup is complete, inform current settings to BgScan
 if( iIsStartupComplete )
 {
 DEBUG( "CWlmServer::UpdateWlanSettings() - notifying settings to BgScan provider" );
 iBgScanProviderSettings = MWlanBgScanProvider::TWlanBgScanSettings( settings.backgroundScanInterval,
 // CWlmServer::NotifyBackgroundScanDone
 // ---------------------------------------------------------
 //
 void CWlmServer::NotifyBackgroundScanDone(
 ScanList* aScanList,
-core_type_list_c<u32_t>* aIapIdList )
+core_type_list_c<core_iap_availability_data_s>& aIapAvailabilityData )
 {
 DEBUG( "CWlmServer::NotifyBackgroundScanDone()" );
 ASSERT( aScanList != NULL );
-ASSERT( aIapIdList != NULL );
 // Unload the drivers immediately to conserve power.
 if( !iPlatform->IsWlanDisabled() &&
 iConnectionState == EWlanStateNotConnected )
 {
 iCoreServer->unload_drivers();
 // Update Cached results
 iCache->UpdateScanList( aScanList );
 TBool newIaps( EFalse );
 TBool lostIaps( EFalse );
 iCache->UpdateAvailableNetworksList(
-*aIapIdList,
+aIapAvailabilityData,
 networkList,
 newIaps,
 lostIaps );
 networkList.Close();
 switch ( iConnectionState )
 {
 case EWlanStateNotConnected:
 DEBUG( "CWlmServer::notify() - STATE: EWlanStateNotConnected" );
 iIsRoaming = EFalse;
+iConnectionIapId = 0;
 // set icon to "not available"
 SetIconState( EWlmIconStatusNotAvailable );
 // if link was unintentionally lost, scan aggressively
 DEBUG( "CWlmServer::notify() - STATE: EWlmNotifyAcTrafficModeChanged<ind>" );
 break;
 case EWlmNotifyAcTrafficStatusChanged:
 DEBUG( "CWlmServer::notify() - STATE: EWlmNotifyAcTrafficStatusChanged<ind>" );
 break;
+case EWlmNotifyRcpChanged:
+DEBUG( "CWlmServer::notify() - STATE: EWlmNotifyRcpChanged<ind>" );
+if( static_cast<core_rcp_class_e>( data[0] ) == core_rcp_normal )
+{
+TInt idx = iIapWeakList.Find( iConnectionIapId );
+if( idx >= 0 )
+{
+DEBUG1( "CWlmServer::notify() - removing IAP %u from weak list",
+iConnectionIapId );
+iIapWeakList.Remove( idx );
+}
+}
+else
+{
+TInt idx = iIapWeakList.Find( iConnectionIapId );
+if( idx == KErrNotFound )
+{
+DEBUG1( "CWlmServer::notify() - adding IAP %u to weak list",
+iConnectionIapId );
+iIapWeakList.Append( iConnectionIapId );
+}
+}
+break;
 default:
 break;
 }
 }
 delete iapSsidList;
 iapSsidList = NULL;
 ScanList* scanList =
 reinterpret_cast<ScanList*>( aRequest.iParam2 );
-core_type_list_c<u32_t>* idList =
+core_type_list_c<core_iap_availability_data_s>* iapAvailabilityList =
-reinterpret_cast<core_type_list_c<u32_t>*>( aRequest.iParam1 );
+reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( aRequest.iParam1 );
 core_type_list_c<core_iap_data_s>* iapDataList =
 reinterpret_cast<core_type_list_c<core_iap_data_s>*>( aRequest.iParam0 );
 delete iapDataList;
 iapDataList = NULL;
 {
 DEBUG( "CWlmServer::CompleteInternalRequest() - this request was handled by core" );
 if( aStatus == core_error_ok )
 {
-NotifyBackgroundScanDone( scanList, idList );
+NotifyBackgroundScanDone( scanList, *iapAvailabilityList );
 // cache takes the ownership of the scanList
 scanList = NULL;
 }
 	}
 else
 DEBUG( "CWlmServer::CompleteInternalRequest() - this request was not handled by core" );
 }
 delete scanList;
 scanList = NULL;
-delete idList;
+delete iapAvailabilityList;
-idList = NULL;
+iapAvailabilityList = NULL;
 break;
 }
 case KWlanIntCmdNull: // Fall through on purpose
 default:
 case EGetAvailableIaps:
 {
 // Create pointers to parameters
 core_type_list_c<core_ssid_entry_s>* iapSsidList;
 ScanList* scanList;
-core_type_list_c<u32_t>* coreIdList;
+core_type_list_c<core_iap_availability_data_s>* coreAvailabilityList;
 core_type_list_c<core_iap_data_s>* iapDataList;
+TBool isFiltered( reinterpret_cast<TBool>( aRequest.iParam4 ) );
+DEBUG1( "CWlmServer::CompleteExternalRequest() - isFiltered: %u",
+isFiltered );
 iapSsidList = reinterpret_cast<core_type_list_c<core_ssid_entry_s>*>( aRequest.iParam3 );
 iapDataList = reinterpret_cast<core_type_list_c<core_iap_data_s>*>( aRequest.iParam0 );
 TUint* completedScanTime = reinterpret_cast<TUint*>( aRequest.iTime );
 ScanList* completedScanList = reinterpret_cast<ScanList*>( aRequest.iParam2);
-core_type_list_c<u32_t>* completedIdList = reinterpret_cast<core_type_list_c<u32_t>*>( aRequest.iParam1 );
+core_type_list_c<core_iap_availability_data_s>* completedAvailabilityList =
+reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( aRequest.iParam1 );
 if( aTriggerRequest == NULL )
 {
 DEBUG( "CWlmServer::CompleteExternalRequest() - GetAvailableIaps request handled by core" );
 scanList = reinterpret_cast<ScanList*>( aRequest.iParam2);
-coreIdList = reinterpret_cast<core_type_list_c<u32_t>*>( aRequest.iParam1 );
+coreAvailabilityList = reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( aRequest.iParam1 );
 }
 else
 {
 DEBUG( "CWlmServer::CompleteExternalRequest() - GetAvailableIaps request not handled by core" );
 //Use the results of the triggering request to complete also this other request
 scanList = reinterpret_cast<ScanList*>( aTriggerRequest->iParam2);
-coreIdList = reinterpret_cast<core_type_list_c<u32_t>*>( aTriggerRequest->iParam1 );
+coreAvailabilityList = reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( aTriggerRequest->iParam1 );
 }
 delete iapSsidList;
 iapSsidList = NULL;
 delete iapDataList;
 TBool lostIaps( EFalse );
 if( aTriggerRequest == NULL )
 {
 iCache->UpdateAvailableNetworksList(
-*coreIdList,
+*coreAvailabilityList,
 networkList,
 newIaps,
 lostIaps );
 }
 networkList.Close();
-TWlmAvailableIaps tmp;
+TWlmAvailableIaps tmp = { 0 };
-TUint32* pInt = coreIdList->first();
+core_iap_availability_data_s* pInt = coreAvailabilityList->first();
-TInt idx = 0;
+if( isFiltered )
-while( pInt )
 {
-DEBUG1( "CWlmServer::CompleteExternalRequest() - IAP %u is available",
+while( pInt && tmp.count < KWlmMaxAvailableIaps )
-*pInt );
+{
-tmp.iaps[ idx ] = *pInt;
+if( pInt->rcpi < iDeviceSettings.minRcpiForIapAvailability )
-idx++;
+{
-pInt = coreIdList->next();
+DEBUG3( "CWlmServer::CompleteExternalRequest() - IAP %u filtered, RCPI is too weak (%u vs %u)",
+pInt->id, pInt->rcpi, iDeviceSettings.minRcpiForIapAvailability );
+}
+else if( iIapWeakList.Find( pInt->id ) != KErrNotFound )
+{
+if( pInt->rcpi < iDeviceSettings.rcpiTrigger )
+{
+DEBUG3( "CWlmServer::CompleteExternalRequest() - IAP %u filtered, in weak list and RCPI is too weak (%u vs %u)",
+pInt->id, pInt->rcpi, iDeviceSettings.rcpiTrigger );
+}
+else
+{
+DEBUG2( "CWlmServer::CompleteExternalRequest() - IAP %u is available, RCPI is %u, removed from weak list",
+pInt->id, pInt->rcpi );
+tmp.iaps[tmp.count].iapId = pInt->id;
+tmp.iaps[tmp.count++].rcpi = pInt->rcpi;
+iIapWeakList.Remove(
+iIapWeakList.Find( pInt->id ) );
+}
+}
+else
+{
+DEBUG2( "CWlmServer::CompleteExternalRequest() - IAP %u is available, RCPI is %u",
+pInt->id, pInt->rcpi );
+tmp.iaps[tmp.count].iapId = pInt->id;
+tmp.iaps[tmp.count++].rcpi = pInt->rcpi;
+}
+pInt = coreAvailabilityList->next();
+}
 }
+else
-tmp.count = idx;
+{
+while( pInt && tmp.count < KWlmMaxAvailableIaps )
+{
+if( pInt->rcpi >= iDeviceSettings.rcpiTrigger &&
+iIapWeakList.Find( pInt->id ) != KErrNotFound )
+{
+DEBUG2( "CWlmServer::CompleteExternalRequest() - IAP %u is available, RCPI is %u, removed from weak list",
+pInt->id, pInt->rcpi );
+iIapWeakList.Remove(
+iIapWeakList.Find( pInt->id ) );
+}
+else
+{
+DEBUG2( "CWlmServer::CompleteExternalRequest() - IAP %u is available, RCPI is %u",
+pInt->id, pInt->rcpi );
+}
+tmp.iaps[tmp.count].iapId = pInt->id;
+tmp.iaps[tmp.count++].rcpi = pInt->rcpi;
+pInt = coreAvailabilityList->next();
+}
+}
 if( IsSessionActive( aRequest ) )
 {
 TPckg<TWlmAvailableIaps> outPckg( tmp );
 aRequest.iMessage.Write( 0, outPckg );
 }
 if( aTriggerRequest == NULL )
 {
-DEBUG("CWlmServer::CompleteExternalRequest() - delete iapIdList" );
+DEBUG("CWlmServer::CompleteExternalRequest() - delete coreAvailabilityList" );
-delete coreIdList;
+delete coreAvailabilityList;
 }
 else
 {
 // If this completed request was not the triggering request then there is no need
 // to cache anything. The triggering request results will be cached.
-delete completedIdList;
+delete completedAvailabilityList;
 delete completedScanList;
 }
 // handle scan list
 if( aTriggerRequest == NULL )
 else
 {
 // scan failed due to some reason: not caching anything
 if( aTriggerRequest == NULL )
 {
-delete coreIdList;
+delete coreAvailabilityList;
 delete scanList;
 }
 else
 {
 // Delete only the lists of the completed request. Triggering request lists are
 // deleted later on when that request is actually handled.
-delete completedIdList;
+delete completedAvailabilityList;
 delete completedScanList;
 }
 }
 delete completedScanTime;
 break;
 ieLength <= KMaxSSIDLength )
 {
 TWlanAvailableNetwork network;
 network.ssid.Copy( ieData, ieLength );
 network.securityMode = info.SecurityMode();
+network.rcpi = info.RXLevel();
 if( info.OperatingMode() == WlanOperatingModeInfra )
 {
 network.networkType = Infrastructure;
 }
 else
 {
 network.networkType = Adhoc;
 }
-if ( aNetworkList.Find( network, isEqual ) == KErrNotFound )
+TInt idx = aNetworkList.Find( network, isEqual );
+if ( idx == KErrNotFound )
 {
 DEBUG1S( "CWlmServer::GetNetworkList() - appending SSID ",
 ieLength, ieData );
 aNetworkList.Append( network );
+}
+else if( idx >= 0 &&
+aNetworkList[idx].rcpi < network.rcpi )
+{
+aNetworkList[idx].rcpi = network.rcpi;
 }
 }
 }
 return KErrNone;
 }
 iapList.Close();
 // Create output list
-core_type_list_c<u32_t>* iapIdList = new core_type_list_c<u32_t>;
+core_type_list_c<core_iap_availability_data_s>* iapAvailabilityList =
-if( iapIdList == NULL )
+new core_type_list_c<core_iap_availability_data_s>;
+if( iapAvailabilityList == NULL )
 {
 DEBUG( "ERROR: Out of memory" );
 delete iapDataList;
 delete iapSsidList;
 return KErrNoMemory;
 if( scanList == NULL )
 {
 DEBUG( "CWlmServer::BackgroundScanRequest() - Out of memory when instantiating ScanList" );
 delete iapDataList;
 delete iapSsidList;
-delete iapIdList;
+delete iapAvailabilityList;
 return KErrNoMemory;
 }
 TUint* scanTime = new TUint(
 CalculateScanStartTime( aScanStartInterval ) );
 {
 DEBUG( "CWlmServer::BackgroundScanRequest() - unable to instantiate TUint" );
 delete iapDataList;
 delete iapSsidList;
-delete iapIdList;
+delete iapAvailabilityList;
 delete scanList;
 return KErrNoMemory;
 }
 // create mapping
 SRequestMapEntry mapEntry;
 mapEntry.iFunction = EGetAvailableIaps;
 mapEntry.iRequestId = KWlanIntCmdBackgroundScan;
 mapEntry.iSessionId = 0;
 mapEntry.iParam0 = iapDataList;
-mapEntry.iParam1 = iapIdList;
+mapEntry.iParam1 = iapAvailabilityList;
 mapEntry.iParam2 = scanList;
 mapEntry.iParam3 = iapSsidList;
+mapEntry.iParam4 = reinterpret_cast<TAny*>( EFalse );
 mapEntry.iTime = scanTime;
 iRequestMap.Append( mapEntry );
 if( IsOnlyTimedScanRequestInRequestMap( mapEntry ) || *scanTime < iScanSchedulingTimerExpiration )
 {
 // Scan scheduling timer needs to be set again because this request needs the results earlier
 UpdateScanSchedulingTimer( *scanTime, mapEntry.iRequestId );
 }
 self->iRequestMap[index].iFunction == EGetAvailableIaps )
 {
 DEBUG( "CWlmServer::ScanSchedulingTimerExpired() - GetAvailableIaps requested" );
 core_type_list_c<core_iap_data_s>* iapDataList = reinterpret_cast<core_type_list_c<core_iap_data_s>*>( self->iRequestMap[index].iParam0 );
-core_type_list_c<u32_t>* iapIdList =  reinterpret_cast<core_type_list_c<u32_t>*>( self->iRequestMap[index].iParam1 );
+core_type_list_c<core_iap_availability_data_s>* iapAvailabilityList =
+reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( self->iRequestMap[index].iParam1 );
 ScanList* scanList =  reinterpret_cast<ScanList*>( self->iRequestMap[index].iParam2 );
 core_type_list_c<core_ssid_entry_s>* iapSsidList =  reinterpret_cast<core_type_list_c<core_ssid_entry_s>*>( self->iRequestMap[index].iParam3 );
 TUint* scanTime =  reinterpret_cast<TUint*>( self->iRequestMap[index].iTime );
 // If the device is roaming OR there are not WLAN IAPs defined in the device
 self->iRequestMap[index].iMessage.Complete( KErrNone );
 }
 delete iapDataList;
 iapDataList = NULL;
-delete iapIdList;
+delete iapAvailabilityList;
-iapIdList = NULL;
+iapAvailabilityList = NULL;
 delete scanList;
 scanList = NULL;
 delete iapSsidList;
 iapSsidList = NULL;
 delete scanTime;
 {
 DEBUG( "CWlmServer::ScanSchedulingTimerExpired() - starting background scan, cancel timer" );
 // pass request to core
 core_type_list_c<core_iap_data_s>* iapDataList = reinterpret_cast<core_type_list_c<core_iap_data_s>*>( self->iRequestMap[index].iParam0 );
 core_type_list_c<core_ssid_entry_s>* iapSsidList = reinterpret_cast<core_type_list_c<core_ssid_entry_s>*>( self->iRequestMap[index].iParam3 );
-core_type_list_c<u32_t>* iapIdList = reinterpret_cast<core_type_list_c<u32_t>*>( self->iRequestMap[index].iParam1 );
+core_type_list_c<core_iap_availability_data_s>* iapAvailabilityList =
+reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( self->iRequestMap[index].iParam1 );
 ScanList* scanList = reinterpret_cast<ScanList*>( self->iRequestMap[index].iParam2 );
 self->iCoreServer->get_available_iaps(
 self->iRequestMap[index].iRequestId,
 isActiveScanAllowed,
 *iapDataList,
-*iapIdList,
+*iapAvailabilityList,
 iapSsidList,
 *scanList );
 self->iScanSchedulingTimer->Cancel();
 }
 DEBUG( "CWlmServer::ScanSchedulingTimerExpired() - starting GetAvailableIaps, cancel timer" );
 // pass request to core
 core_type_list_c<core_iap_data_s>* iapDataList = reinterpret_cast<core_type_list_c<core_iap_data_s>*>( self->iRequestMap[index].iParam0 );
 core_type_list_c<core_ssid_entry_s>* iapSsidList = reinterpret_cast<core_type_list_c<core_ssid_entry_s>*>( self->iRequestMap[index].iParam3 );
-core_type_list_c<u32_t>* iapIdList = reinterpret_cast<core_type_list_c<u32_t>*>( self->iRequestMap[index].iParam1 );
+core_type_list_c<core_iap_availability_data_s>* iapAvailabilityList =
+reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( self->iRequestMap[index].iParam1 );
 ScanList* scanList = reinterpret_cast<ScanList*>( self->iRequestMap[index].iParam2 );
 self->iCoreServer->get_available_iaps(
 self->iRequestMap[index].iRequestId,
 isActiveScanAllowed,
 *iapDataList,
-*iapIdList,
+*iapAvailabilityList,
 iapSsidList,
 *scanList );
 self->iScanSchedulingTimer->Cancel();
 }
 iScanSchedulingTimer->Cancel();
 DEBUG( "CWlmServer::CancelScan() - remove entry from request map" );
 SRequestMapEntry entry = iRequestMap[index];
 delete reinterpret_cast<core_type_list_c<core_iap_data_s>*>( entry.iParam0 );
-delete reinterpret_cast<core_type_list_c<u32_t>*>( entry.iParam1 );
+delete reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( entry.iParam1 );
 delete reinterpret_cast<ScanList*>( entry.iParam2);
 delete reinterpret_cast<core_type_list_c<core_ssid_entry_s>*>( entry.iParam3 );
 delete reinterpret_cast<TUint*>( entry.iTime );
 iRequestMap.Remove( index );
 DEBUG( "CWlmServer::CancelScan() - just remove the entry from the request map" );
 DEBUG( "CWlmServer::CancelScan() - remove entry from request map" );
 SRequestMapEntry entry = iRequestMap[index];
 delete reinterpret_cast<core_type_list_c<core_iap_data_s>*>( entry.iParam0 );
-delete reinterpret_cast<core_type_list_c<u32_t>*>( entry.iParam1 );
+delete reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( entry.iParam1 );
 delete reinterpret_cast<ScanList*>( entry.iParam2);
 delete reinterpret_cast<core_type_list_c<core_ssid_entry_s>*>( entry.iParam3 );
 delete reinterpret_cast<TUint*>( entry.iTime );
 iRequestMap.Remove( index );
 }
 {
 DEBUG( "CWlmServer::HandleSsidListAvailabilityL()" );
 ScanList* scanList =
 reinterpret_cast<ScanList*>( aMapEntry.iParam2 );
-core_type_list_c<u32_t>* iapIdList =
+core_type_list_c<core_iap_availability_data_s>* iapAvailabilityList =
-reinterpret_cast<core_type_list_c<u32_t>*>( aMapEntry.iParam1 );
+reinterpret_cast<core_type_list_c<core_iap_availability_data_s>*>( aMapEntry.iParam1 );
 /**
 * Go through the IAP list and find IAPs that haven't been found
 * during GetAvailableIaps and have an SSID list attached.
 */
 RArray<TWlanLimitedIapData> attachedIapList;
 CleanupClosePushL( attachedIapList );
 const RArray<TWlanLimitedIapData>& cachedIapList(
 iCache->CachedIapDataList() );
-core_type_list_iterator_c<u32_t> iter( *iapIdList );
+core_type_list_iterator_c<core_iap_availability_data_s> iter( *iapAvailabilityList );
 for( TInt idx( 0 ); idx < cachedIapList.Count(); ++idx )
 {
 TBool isFound( EFalse );
-for( u32_t* item = iter.first(); !isFound && item; item = iter.next() )
+for( core_iap_availability_data_s* item = iter.first(); !isFound && item; item = iter.next() )
 {
-if( *item == cachedIapList[idx].iapId )
+if( item->id == cachedIapList[idx].iapId )
 {
 isFound = ETrue;
 }
 }
 if( !isFound )
 CleanupStack::PushL( ssidList );
 iSsidListDb->ReadListL(
 attachedIapList[idx].iapId,
 *ssidList );
 TBool isMatch( EFalse );
+TUint rcpi( 0 );
 for( TInt iidx( 0 ); !isMatch && iidx < networkList.Count(); ++iidx )
 {
 if( attachedIapList[idx].networkType == networkList[iidx].networkType &&
 ssidList->IsInList( networkList[iidx].ssid ) )
 {
+rcpi = networkList[iidx].rcpi;
 isMatch = ETrue;
 }
 }
 if( isMatch )
 DEBUG( "CWlmServer::HandleSsidListAvailabilityL() - matching SSID found" );
 /**
 * A match has been found, mark the IAP as available.
 */
-u32_t* iapId = new (ELeave) u32_t(
+core_iap_availability_data_s* data = new (ELeave) core_iap_availability_data_s;
-attachedIapList[idx].iapId );
+data->id = attachedIapList[idx].iapId;
-iapIdList->append(
+data->rcpi = rcpi;
-iapId );
+core_error_e ret = iapAvailabilityList->append(
+data );
+if( ret != core_error_ok )
+{
+delete data;
+}
+data = NULL;
 }
 else
 {
 DEBUG( "CWlmServer::HandleSsidListAvailabilityL() - no matching SSIDs found for IAP" );
 }

branch	RCL_3
changeset 34	13838cf40350
parent 20	a9473894c0f1
child 42	a828660c511c