/*
|
* Copyright (C) 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
package com.android.server.wifi;
|
|
import android.net.wifi.ScanResult;
|
import android.net.wifi.WifiConfiguration;
|
import android.net.wifi.WifiEnterpriseConfig;
|
import android.os.Process;
|
import android.telephony.TelephonyManager;
|
import android.util.LocalLog;
|
|
import com.android.server.wifi.WifiNetworkSelector.NetworkEvaluator;
|
import com.android.server.wifi.util.ScanResultUtil;
|
import com.android.server.wifi.util.TelephonyUtil;
|
|
import java.util.List;
|
|
import javax.annotation.concurrent.NotThreadSafe;
|
|
/**
|
* Evaluator to select a Carrier Wi-Fi network which can be connected to. The evaluator performs
|
* two functions:
|
*
|
* 1. Filtering: figure out which of the networks is a Carrier Wi-Fi network (using the
|
* {@link CarrierNetworkConfig} APIs).
|
* 2. Evaluation: current evaluator API has 2 outputs (effectively):
|
* - Connectable networks: all networks which match #1 will be fed to this API
|
* - Selected network: a single network 'selected' by the evaluator. A simple max(RSSI) will be
|
* used to pick one network from among the connectable networks.
|
*
|
* Note: This class is not thread safe and meant to be used only from {@link WifiNetworkSelector}.
|
*/
|
@NotThreadSafe
|
public class CarrierNetworkEvaluator implements NetworkEvaluator {
|
private static final String TAG = "CarrierNetworkEvaluator";
|
|
private final WifiConfigManager mWifiConfigManager;
|
private final CarrierNetworkConfig mCarrierNetworkConfig;
|
private final LocalLog mLocalLog;
|
private final WifiInjector mWifiInjector;
|
private TelephonyManager mTelephonyManager;
|
|
public CarrierNetworkEvaluator(WifiConfigManager wifiConfigManager,
|
CarrierNetworkConfig carrierNetworkConfig, LocalLog localLog,
|
WifiInjector wifiInjector) {
|
mWifiConfigManager = wifiConfigManager;
|
mCarrierNetworkConfig = carrierNetworkConfig;
|
mLocalLog = localLog;
|
mWifiInjector = wifiInjector;
|
}
|
|
private TelephonyManager getTelephonyManager() {
|
if (mTelephonyManager == null) {
|
mTelephonyManager = mWifiInjector.makeTelephonyManager();
|
}
|
return mTelephonyManager;
|
}
|
|
@Override
|
public @EvaluatorId int getId() {
|
return EVALUATOR_ID_CARRIER;
|
}
|
|
@Override
|
public String getName() {
|
return TAG;
|
}
|
|
@Override
|
public void update(List<ScanDetail> scanDetails) {
|
// nothing to be done
|
}
|
|
@Override
|
public WifiConfiguration evaluateNetworks(List<ScanDetail> scanDetails,
|
WifiConfiguration currentNetwork, String currentBssid, boolean connected,
|
boolean untrustedNetworkAllowed, OnConnectableListener onConnectableListener) {
|
if (!mCarrierNetworkConfig.isCarrierEncryptionInfoAvailable()) {
|
return null;
|
}
|
|
int currentMaxRssi = Integer.MIN_VALUE;
|
WifiConfiguration configWithMaxRssi = null;
|
for (ScanDetail scanDetail : scanDetails) {
|
ScanResult scanResult = scanDetail.getScanResult();
|
|
if (!ScanResultUtil.isScanResultForEapNetwork(scanResult)
|
|| !mCarrierNetworkConfig.isCarrierNetwork(scanResult.SSID)) {
|
continue;
|
}
|
int eapType = mCarrierNetworkConfig.getNetworkEapType(scanResult.SSID);
|
if (!TelephonyUtil.isSimEapMethod(eapType)) {
|
mLocalLog.log(TAG + ": eapType is not a carrier eap method: " + eapType);
|
continue;
|
}
|
// If the user previously forgot this network, don't select it.
|
if (mWifiConfigManager.wasEphemeralNetworkDeleted(
|
ScanResultUtil.createQuotedSSID(scanResult.SSID))) {
|
mLocalLog.log(TAG + ": Ignoring disabled ephemeral SSID: "
|
+ WifiNetworkSelector.toScanId(scanResult));
|
continue;
|
}
|
|
WifiConfiguration config = ScanResultUtil.createNetworkFromScanResult(scanResult);
|
config.ephemeral = true;
|
if (config.enterpriseConfig == null) {
|
config.enterpriseConfig = new WifiEnterpriseConfig();
|
}
|
config.enterpriseConfig.setEapMethod(eapType);
|
|
// Check if we already have a network with the same credentials in WifiConfigManager
|
// database. If yes, we should check if the network is currently blacklisted.
|
WifiConfiguration existingNetwork =
|
mWifiConfigManager.getConfiguredNetwork(config.configKey());
|
if (existingNetwork != null
|
&& !existingNetwork.getNetworkSelectionStatus().isNetworkEnabled()
|
&& !mWifiConfigManager.tryEnableNetwork(existingNetwork.networkId)) {
|
mLocalLog.log(TAG + ": Ignoring blacklisted network: "
|
+ WifiNetworkSelector.toNetworkString(existingNetwork));
|
continue;
|
}
|
|
// Add the newly created WifiConfiguration to WifiConfigManager.
|
NetworkUpdateResult result = mWifiConfigManager.addOrUpdateNetwork(config,
|
Process.WIFI_UID);
|
if (!result.isSuccess()) {
|
mLocalLog.log(TAG + ": Failed to add carrier network: " + config);
|
continue;
|
}
|
if (!mWifiConfigManager.enableNetwork(result.getNetworkId(), false, Process.WIFI_UID)) {
|
mLocalLog.log(TAG + ": Failed to enable carrier network: " + config);
|
continue;
|
}
|
if (!mWifiConfigManager.setNetworkCandidateScanResult(result.getNetworkId(), scanResult,
|
0)) {
|
mLocalLog.log(
|
TAG + ": Failed to set network candidate for carrier network: " + config);
|
|
continue;
|
}
|
|
config = mWifiConfigManager.getConfiguredNetwork(result.getNetworkId());
|
|
WifiConfiguration.NetworkSelectionStatus nss = null;
|
if (config != null) {
|
nss = config.getNetworkSelectionStatus();
|
}
|
if (nss == null) {
|
mLocalLog.log(TAG + ": null network selection status for: " + config);
|
continue;
|
}
|
if (nss.getCandidate() != null && nss.getCandidate().level < scanResult.level) {
|
mWifiConfigManager.updateScanDetailForNetwork(result.getNetworkId(), scanDetail);
|
}
|
|
onConnectableListener.onConnectable(scanDetail, config, 0);
|
if (scanResult.level > currentMaxRssi) {
|
configWithMaxRssi = config;
|
currentMaxRssi = scanResult.level;
|
}
|
}
|
|
return configWithMaxRssi;
|
}
|
}
|
