/*
* Copyright (C) 2014 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;
import android.Manifest.permission;
import android.annotation.Nullable;
import android.app.AppOpsManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.net.NetworkScoreManager;
import android.net.NetworkScorerAppData;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.Log;
import com.android.internal.R;
import com.android.internal.annotations.VisibleForTesting;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Internal class for discovering and managing the network scorer/recommendation application.
*
* @hide
*/
@VisibleForTesting
public class NetworkScorerAppManager {
private static final String TAG = "NetworkScorerAppManager";
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
private final Context mContext;
private final SettingsFacade mSettingsFacade;
public NetworkScorerAppManager(Context context) {
this(context, new SettingsFacade());
}
@VisibleForTesting
public NetworkScorerAppManager(Context context, SettingsFacade settingsFacade) {
mContext = context;
mSettingsFacade = settingsFacade;
}
/**
* Returns the list of available scorer apps. The list will be empty if there are
* no valid scorers.
*/
@VisibleForTesting
public List<NetworkScorerAppData> getAllValidScorers() {
if (VERBOSE) Log.v(TAG, "getAllValidScorers()");
final PackageManager pm = mContext.getPackageManager();
final Intent serviceIntent = new Intent(NetworkScoreManager.ACTION_RECOMMEND_NETWORKS);
final List<ResolveInfo> resolveInfos =
pm.queryIntentServices(serviceIntent, PackageManager.GET_META_DATA);
if (resolveInfos == null || resolveInfos.isEmpty()) {
if (DEBUG) Log.d(TAG, "Found 0 Services able to handle " + serviceIntent);
return Collections.emptyList();
}
List<NetworkScorerAppData> appDataList = new ArrayList<>();
for (int i = 0; i < resolveInfos.size(); i++) {
final ServiceInfo serviceInfo = resolveInfos.get(i).serviceInfo;
if (hasPermissions(serviceInfo.applicationInfo.uid, serviceInfo.packageName)) {
if (VERBOSE) {
Log.v(TAG, serviceInfo.packageName + " is a valid scorer/recommender.");
}
final ComponentName serviceComponentName =
new ComponentName(serviceInfo.packageName, serviceInfo.name);
final String serviceLabel = getRecommendationServiceLabel(serviceInfo, pm);
final ComponentName useOpenWifiNetworksActivity =
findUseOpenWifiNetworksActivity(serviceInfo);
final String networkAvailableNotificationChannelId =
getNetworkAvailableNotificationChannelId(serviceInfo);
appDataList.add(
new NetworkScorerAppData(serviceInfo.applicationInfo.uid,
serviceComponentName, serviceLabel, useOpenWifiNetworksActivity,
networkAvailableNotificationChannelId));
} else {
if (VERBOSE) Log.v(TAG, serviceInfo.packageName
+ " is NOT a valid scorer/recommender.");
}
}
return appDataList;
}
@Nullable
private String getRecommendationServiceLabel(ServiceInfo serviceInfo, PackageManager pm) {
if (serviceInfo.metaData != null) {
final String label = serviceInfo.metaData
.getString(NetworkScoreManager.RECOMMENDATION_SERVICE_LABEL_META_DATA);
if (!TextUtils.isEmpty(label)) {
return label;
}
}
CharSequence label = serviceInfo.loadLabel(pm);
return label == null ? null : label.toString();
}
@Nullable
private ComponentName findUseOpenWifiNetworksActivity(ServiceInfo serviceInfo) {
if (serviceInfo.metaData == null) {
if (DEBUG) {
Log.d(TAG, "No metadata found on " + serviceInfo.getComponentName());
}
return null;
}
final String useOpenWifiPackage = serviceInfo.metaData
.getString(NetworkScoreManager.USE_OPEN_WIFI_PACKAGE_META_DATA);
if (TextUtils.isEmpty(useOpenWifiPackage)) {
if (DEBUG) {
Log.d(TAG, "No use_open_wifi_package metadata found on "
+ serviceInfo.getComponentName());
}
return null;
}
final Intent enableUseOpenWifiIntent = new Intent(NetworkScoreManager.ACTION_CUSTOM_ENABLE)
.setPackage(useOpenWifiPackage);
final ResolveInfo resolveActivityInfo = mContext.getPackageManager()
.resolveActivity(enableUseOpenWifiIntent, 0 /* flags */);
if (VERBOSE) {
Log.d(TAG, "Resolved " + enableUseOpenWifiIntent + " to " + resolveActivityInfo);
}
if (resolveActivityInfo != null && resolveActivityInfo.activityInfo != null) {
return resolveActivityInfo.activityInfo.getComponentName();
}
return null;
}
@Nullable
private static String getNetworkAvailableNotificationChannelId(ServiceInfo serviceInfo) {
if (serviceInfo.metaData == null) {
if (DEBUG) {
Log.d(TAG, "No metadata found on " + serviceInfo.getComponentName());
}
return null;
}
return serviceInfo.metaData.getString(
NetworkScoreManager.NETWORK_AVAILABLE_NOTIFICATION_CHANNEL_ID_META_DATA);
}
/**
* Get the application to use for scoring networks.
*
* @return the scorer app info or null if scoring is disabled (including if no scorer was ever
* selected) or if the previously-set scorer is no longer a valid scorer app (e.g. because
* it was disabled or uninstalled).
*/
@Nullable
@VisibleForTesting
public NetworkScorerAppData getActiveScorer() {
final int enabledSetting = getNetworkRecommendationsEnabledSetting();
if (enabledSetting == NetworkScoreManager.RECOMMENDATIONS_ENABLED_FORCED_OFF) {
return null;
}
return getScorer(getNetworkRecommendationsPackage());
}
private NetworkScorerAppData getScorer(String packageName) {
if (TextUtils.isEmpty(packageName)) {
return null;
}
// Otherwise return the recommendation provider (which may be null).
List<NetworkScorerAppData> apps = getAllValidScorers();
for (int i = 0; i < apps.size(); i++) {
NetworkScorerAppData app = apps.get(i);
if (app.getRecommendationServicePackageName().equals(packageName)) {
return app;
}
}
return null;
}
private boolean hasPermissions(final int uid, final String packageName) {
return hasScoreNetworksPermission(packageName)
&& canAccessLocation(uid, packageName);
}
private boolean hasScoreNetworksPermission(String packageName) {
final PackageManager pm = mContext.getPackageManager();
return pm.checkPermission(permission.SCORE_NETWORKS, packageName)
== PackageManager.PERMISSION_GRANTED;
}
private boolean canAccessLocation(int uid, String packageName) {
final PackageManager pm = mContext.getPackageManager();
final AppOpsManager appOpsManager =
(AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE);
return isLocationModeEnabled()
&& pm.checkPermission(permission.ACCESS_COARSE_LOCATION, packageName)
== PackageManager.PERMISSION_GRANTED
&& appOpsManager.noteOp(AppOpsManager.OP_COARSE_LOCATION, uid, packageName)
== AppOpsManager.MODE_ALLOWED;
}
private boolean isLocationModeEnabled() {
return mSettingsFacade.getSecureInt(mContext, Settings.Secure.LOCATION_MODE,
Settings.Secure.LOCATION_MODE_OFF) != Settings.Secure.LOCATION_MODE_OFF;
}
/**
* Set the specified package as the default scorer application.
*
* <p>The caller must have permission to write to {@link Settings.Global}.
*
* @param packageName the packageName of the new scorer to use. If null, scoring will be forced
* off, otherwise the scorer will only be set if it is a valid scorer
* application.
* @return true if the package was a valid scorer (including <code>null</code>) and now
* represents the active scorer, false otherwise.
*/
@VisibleForTesting
public boolean setActiveScorer(String packageName) {
final String oldPackageName = getNetworkRecommendationsPackage();
if (TextUtils.equals(oldPackageName, packageName)) {
// No change.
return true;
}
if (TextUtils.isEmpty(packageName)) {
Log.i(TAG, "Network scorer forced off, was: " + oldPackageName);
setNetworkRecommendationsPackage(null);
setNetworkRecommendationsEnabledSetting(
NetworkScoreManager.RECOMMENDATIONS_ENABLED_FORCED_OFF);
return true;
}
// We only make the change if the new package is valid.
if (getScorer(packageName) != null) {
Log.i(TAG, "Changing network scorer from " + oldPackageName + " to " + packageName);
setNetworkRecommendationsPackage(packageName);
setNetworkRecommendationsEnabledSetting(NetworkScoreManager.RECOMMENDATIONS_ENABLED_ON);
return true;
} else {
Log.w(TAG, "Requested network scorer is not valid: " + packageName);
return false;
}
}
/**
* Ensures the {@link Settings.Global#NETWORK_RECOMMENDATIONS_PACKAGE} setting points to a valid
* package and {@link Settings.Global#NETWORK_RECOMMENDATIONS_ENABLED} is consistent.
*
* If {@link Settings.Global#NETWORK_RECOMMENDATIONS_PACKAGE} doesn't point to a valid package
* then it will be reverted to the default package specified by
* {@link R.string#config_defaultNetworkRecommendationProviderPackage}. If the default package
* is no longer valid then {@link Settings.Global#NETWORK_RECOMMENDATIONS_ENABLED} will be set
* to <code>0</code> (disabled).
*/
@VisibleForTesting
public void updateState() {
final int enabledSetting = getNetworkRecommendationsEnabledSetting();
if (enabledSetting == NetworkScoreManager.RECOMMENDATIONS_ENABLED_FORCED_OFF) {
// Don't change anything if it's forced off.
if (DEBUG) Log.d(TAG, "Recommendations forced off.");
return;
}
// First, see if the current package is still valid. If so, then we can exit early.
final String currentPackageName = getNetworkRecommendationsPackage();
if (getScorer(currentPackageName) != null) {
if (VERBOSE) Log.v(TAG, currentPackageName + " is the active scorer.");
setNetworkRecommendationsEnabledSetting(NetworkScoreManager.RECOMMENDATIONS_ENABLED_ON);
return;
}
int newEnabledSetting = NetworkScoreManager.RECOMMENDATIONS_ENABLED_OFF;
// the active scorer isn't valid, revert to the default if it's different and valid
final String defaultPackageName = getDefaultPackageSetting();
if (!TextUtils.equals(currentPackageName, defaultPackageName)
&& getScorer(defaultPackageName) != null) {
if (DEBUG) {
Log.d(TAG, "Defaulting the network recommendations app to: "
+ defaultPackageName);
}
setNetworkRecommendationsPackage(defaultPackageName);
newEnabledSetting = NetworkScoreManager.RECOMMENDATIONS_ENABLED_ON;
}
setNetworkRecommendationsEnabledSetting(newEnabledSetting);
}
/**
* Migrates the NETWORK_SCORER_APP Setting to the USE_OPEN_WIFI_PACKAGE Setting.
*/
@VisibleForTesting
public void migrateNetworkScorerAppSettingIfNeeded() {
final String scorerAppPkgNameSetting =
mSettingsFacade.getString(mContext, Settings.Global.NETWORK_SCORER_APP);
if (TextUtils.isEmpty(scorerAppPkgNameSetting)) {
// Early exit, nothing to do.
return;
}
final NetworkScorerAppData currentAppData = getActiveScorer();
if (currentAppData == null) {
// Don't touch anything until we have an active scorer to work with.
return;
}
if (DEBUG) {
Log.d(TAG, "Migrating Settings.Global.NETWORK_SCORER_APP "
+ "(" + scorerAppPkgNameSetting + ")...");
}
// If the new (useOpenWifi) Setting isn't set and the old Setting's value matches the
// new metadata value then update the new Setting with the old value. Otherwise it's a
// mismatch so we shouldn't enable the Setting automatically.
final ComponentName enableUseOpenWifiActivity =
currentAppData.getEnableUseOpenWifiActivity();
final String useOpenWifiSetting =
mSettingsFacade.getString(mContext, Settings.Global.USE_OPEN_WIFI_PACKAGE);
if (TextUtils.isEmpty(useOpenWifiSetting)
&& enableUseOpenWifiActivity != null
&& scorerAppPkgNameSetting.equals(enableUseOpenWifiActivity.getPackageName())) {
mSettingsFacade.putString(mContext, Settings.Global.USE_OPEN_WIFI_PACKAGE,
scorerAppPkgNameSetting);
if (DEBUG) {
Log.d(TAG, "Settings.Global.USE_OPEN_WIFI_PACKAGE set to "
+ "'" + scorerAppPkgNameSetting + "'.");
}
}
// Clear out the old setting so we don't run through the migration code again.
mSettingsFacade.putString(mContext, Settings.Global.NETWORK_SCORER_APP, null);
if (DEBUG) {
Log.d(TAG, "Settings.Global.NETWORK_SCORER_APP migration complete.");
final String setting =
mSettingsFacade.getString(mContext, Settings.Global.USE_OPEN_WIFI_PACKAGE);
Log.d(TAG, "Settings.Global.USE_OPEN_WIFI_PACKAGE is: '" + setting + "'.");
}
}
private String getDefaultPackageSetting() {
return mContext.getResources().getString(
R.string.config_defaultNetworkRecommendationProviderPackage);
}
private String getNetworkRecommendationsPackage() {
return mSettingsFacade.getString(mContext, Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE);
}
private void setNetworkRecommendationsPackage(String packageName) {
mSettingsFacade.putString(mContext,
Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE, packageName);
if (VERBOSE) {
Log.d(TAG, Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE + " set to " + packageName);
}
}
private int getNetworkRecommendationsEnabledSetting() {
return mSettingsFacade.getInt(mContext, Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0);
}
private void setNetworkRecommendationsEnabledSetting(int value) {
mSettingsFacade.putInt(mContext,
Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, value);
if (VERBOSE) {
Log.d(TAG, Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED + " set to " + value);
}
}
/**
* Wrapper around Settings to make testing easier.
*/
public static class SettingsFacade {
public boolean putString(Context context, String name, String value) {
return Settings.Global.putString(context.getContentResolver(), name, value);
}
public String getString(Context context, String name) {
return Settings.Global.getString(context.getContentResolver(), name);
}
public boolean putInt(Context context, String name, int value) {
return Settings.Global.putInt(context.getContentResolver(), name, value);
}
public int getInt(Context context, String name, int defaultValue) {
return Settings.Global.getInt(context.getContentResolver(), name, defaultValue);
}
public int getSecureInt(Context context, String name, int defaultValue) {
return Settings.Secure.getInt(context.getContentResolver(), name, defaultValue);
}
}
}