/*
* 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 android.net;
import android.Manifest.permission;
import android.annotation.Nullable;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.UserHandle;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.Log;
import com.android.internal.R;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Internal class for discovering and managing the network scorer/recommendation application.
*
* @hide
*/
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;
public NetworkScorerAppManager(Context context) {
mContext = context;
}
/**
* Holds metadata about a discovered network scorer/recommendation application.
*/
public static class NetworkScorerAppData {
/** Package name of this scorer app. */
public final String packageName;
/** UID of the scorer app. */
public final int packageUid;
/**
* Name of the recommendation service we can bind to.
*/
public final String recommendationServiceClassName;
public NetworkScorerAppData(String packageName, int packageUid,
String recommendationServiceClassName) {
this.packageName = packageName;
this.packageUid = packageUid;
this.recommendationServiceClassName = recommendationServiceClassName;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("NetworkScorerAppData{");
sb.append("mPackageName='").append(packageName).append('\'');
sb.append(", packageUid=").append(packageUid);
sb.append(", recommendationServiceClassName='")
.append(recommendationServiceClassName).append('\'');
sb.append('}');
return sb.toString();
}
}
/**
* @return A {@link NetworkScorerAppData} instance containing information about the
* best configured network recommendation provider installed or {@code null}
* if none of the configured packages can recommend networks.
*
* <p>A network recommendation provider is any application which:
* <ul>
* <li>Is listed in the <code>config_networkRecommendationPackageNames</code> config.
* <li>Declares the {@link android.Manifest.permission#SCORE_NETWORKS} permission.
* <li>Includes a Service for {@link NetworkScoreManager#ACTION_RECOMMEND_NETWORKS}.
* </ul>
*/
public NetworkScorerAppData getNetworkRecommendationProviderData() {
// Network recommendation apps can only run as the primary user right now.
// http://b/23422763
if (UserHandle.getCallingUserId() != UserHandle.USER_SYSTEM) {
return null;
}
final List<String> potentialPkgs = getPotentialRecommendationProviderPackages();
if (potentialPkgs.isEmpty()) {
if (DEBUG) {
Log.d(TAG, "No Network Recommendation Providers specified.");
}
return null;
}
final PackageManager pm = mContext.getPackageManager();
for (int i = 0; i < potentialPkgs.size(); i++) {
final String potentialPkg = potentialPkgs.get(i);
// Look for the recommendation service class and required receiver.
final ResolveInfo resolveServiceInfo = findRecommendationService(potentialPkg);
if (resolveServiceInfo != null) {
return new NetworkScorerAppData(potentialPkg,
resolveServiceInfo.serviceInfo.applicationInfo.uid,
resolveServiceInfo.serviceInfo.name);
} else {
if (DEBUG) {
Log.d(TAG, potentialPkg + " does not have the required components, skipping.");
}
}
}
// None of the configured packages are valid.
return null;
}
/**
* @return A priority order list of package names that have been granted the
* permission needed for them to act as a network recommendation provider.
* The packages in the returned list may not contain the other required
* network recommendation provider components so additional checks are required
* before making a package the network recommendation provider.
*/
public List<String> getPotentialRecommendationProviderPackages() {
final String[] packageArray = mContext.getResources().getStringArray(
R.array.config_networkRecommendationPackageNames);
if (packageArray == null || packageArray.length == 0) {
if (DEBUG) {
Log.d(TAG, "No Network Recommendation Providers specified.");
}
return Collections.emptyList();
}
if (VERBOSE) {
Log.d(TAG, "Configured packages: " + TextUtils.join(", ", packageArray));
}
List<String> packages = new ArrayList<>();
final PackageManager pm = mContext.getPackageManager();
for (String potentialPkg : packageArray) {
if (pm.checkPermission(permission.SCORE_NETWORKS, potentialPkg)
== PackageManager.PERMISSION_GRANTED) {
packages.add(potentialPkg);
} else {
if (DEBUG) {
Log.d(TAG, potentialPkg + " has not been granted " + permission.SCORE_NETWORKS
+ ", skipping.");
}
}
}
return packages;
}
private ResolveInfo findRecommendationService(String packageName) {
final PackageManager pm = mContext.getPackageManager();
final int resolveFlags = 0;
final Intent serviceIntent = new Intent(NetworkScoreManager.ACTION_RECOMMEND_NETWORKS);
serviceIntent.setPackage(packageName);
final ResolveInfo resolveServiceInfo =
pm.resolveService(serviceIntent, resolveFlags);
if (VERBOSE) {
Log.d(TAG, "Resolved " + serviceIntent + " to " + resolveServiceInfo);
}
if (resolveServiceInfo != null && resolveServiceInfo.serviceInfo != null) {
return resolveServiceInfo;
}
if (VERBOSE) {
Log.v(TAG, packageName + " does not have a service for " + serviceIntent);
}
return null;
}
/**
* 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
public NetworkScorerAppData getActiveScorer() {
if (isNetworkRecommendationsDisabled()) {
// If recommendations are disabled then there can't be an active scorer.
return null;
}
// Otherwise return the recommendation provider (which may be null).
return getNetworkRecommendationProviderData();
}
/**
* Set the specified package as the default scorer application.
*
* <p>The caller must have permission to write to {@link android.provider.Settings.Global}.
*
* @param packageName the packageName of the new scorer to use. If null, scoring will be
* disabled. Otherwise, the scorer will only be set if it is a valid scorer application.
* @return true if the scorer was changed, or false if the package is not a valid scorer or
* a valid network recommendation provider exists.
* @deprecated Scorers are now selected from a configured list.
*/
@Deprecated
public boolean setActiveScorer(String packageName) {
return false;
}
/** Determine whether the application with the given UID is the enabled scorer. */
@Deprecated // Use NetworkScoreManager.isCallerActiveScorer()
public boolean isCallerActiveScorer(int callingUid) {
NetworkScorerAppData defaultApp = getActiveScorer();
if (defaultApp == null) {
return false;
}
return callingUid == defaultApp.packageUid;
}
private boolean isNetworkRecommendationsDisabled() {
final ContentResolver cr = mContext.getContentResolver();
// A value of 1 indicates enabled.
return Settings.Global.getInt(cr, Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0) != 1;
}
}