466 lines
25 KiB
Java
466 lines
25 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2020 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.internal.telephony;
|
||
|
|
|
||
|
|
import android.annotation.Nullable;
|
||
|
|
import android.annotation.UserIdInt;
|
||
|
|
import android.content.ContentResolver;
|
||
|
|
import android.content.Context;
|
||
|
|
import android.content.pm.ApplicationInfo;
|
||
|
|
import android.content.pm.PackageManager;
|
||
|
|
import android.os.Build;
|
||
|
|
import android.os.CarrierAssociatedAppEntry;
|
||
|
|
import android.os.SystemConfigManager;
|
||
|
|
import android.os.UserHandle;
|
||
|
|
import android.permission.LegacyPermissionManager;
|
||
|
|
import android.provider.Settings;
|
||
|
|
import android.telephony.TelephonyManager;
|
||
|
|
import android.util.ArrayMap;
|
||
|
|
import android.util.Log;
|
||
|
|
|
||
|
|
import com.android.internal.annotations.VisibleForTesting;
|
||
|
|
import com.android.internal.telephony.flags.Flags;
|
||
|
|
import com.android.internal.telephony.util.TelephonyUtils;
|
||
|
|
|
||
|
|
import java.util.ArrayList;
|
||
|
|
import java.util.List;
|
||
|
|
import java.util.Map;
|
||
|
|
import java.util.Set;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Utilities to control the states of the system bundled (preinstalled) carrier applications.
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public final class CarrierAppUtils {
|
||
|
|
private static final String TAG = "CarrierAppUtils";
|
||
|
|
|
||
|
|
private static final boolean DEBUG = false; // STOPSHIP if true
|
||
|
|
|
||
|
|
private CarrierAppUtils() {}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Handle preinstalled carrier apps which should be disabled until a matching SIM is inserted.
|
||
|
|
*
|
||
|
|
* Evaluates the list of applications in
|
||
|
|
* {@link SystemConfigManager#getDisabledUntilUsedPreinstalledCarrierApps()}. We want to disable
|
||
|
|
* each such application which is present on the system image until the user inserts a SIM
|
||
|
|
* which causes that application to gain carrier privilege (indicating a "match"), without
|
||
|
|
* interfering with the user if they opt to enable/disable the app explicitly.
|
||
|
|
*
|
||
|
|
* So, for each such app, we either disable until used IFF the app is not carrier privileged AND
|
||
|
|
* in the default state (e.g. not explicitly DISABLED/DISABLED_BY_USER/ENABLED), or we enable if
|
||
|
|
* the app is carrier privileged and in either the default state or DISABLED_UNTIL_USED.
|
||
|
|
*
|
||
|
|
* In addition, there is a list of carrier-associated applications in
|
||
|
|
* {@link SystemConfigManager#getDisabledUntilUsedPreinstalledCarrierAssociatedApps}. Each app
|
||
|
|
* in this list is associated with a carrier app. When the given carrier app is enabled/disabled
|
||
|
|
* per the above, the associated applications are enabled/disabled to match.
|
||
|
|
*
|
||
|
|
* When enabling a carrier app we also grant it default permissions.
|
||
|
|
*
|
||
|
|
* This method is idempotent and is safe to be called at any time; it should be called once at
|
||
|
|
* system startup prior to any application running, as well as any time the set of carrier
|
||
|
|
* privileged apps may have changed.
|
||
|
|
*/
|
||
|
|
public static synchronized void disableCarrierAppsUntilPrivileged(String callingPackage,
|
||
|
|
TelephonyManager telephonyManager, @UserIdInt int userId, Context context) {
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, "disableCarrierAppsUntilPrivileged");
|
||
|
|
}
|
||
|
|
SystemConfigManager config = context.getSystemService(SystemConfigManager.class);
|
||
|
|
Set<String> systemCarrierAppsDisabledUntilUsed =
|
||
|
|
config.getDisabledUntilUsedPreinstalledCarrierApps();
|
||
|
|
Map<String, List<CarrierAssociatedAppEntry>> systemCarrierAssociatedAppsDisabledUntilUsed =
|
||
|
|
config.getDisabledUntilUsedPreinstalledCarrierAssociatedAppEntries();
|
||
|
|
ContentResolver contentResolver = getContentResolverForUser(context, userId);
|
||
|
|
disableCarrierAppsUntilPrivileged(callingPackage, telephonyManager, contentResolver,
|
||
|
|
userId, systemCarrierAppsDisabledUntilUsed,
|
||
|
|
systemCarrierAssociatedAppsDisabledUntilUsed, context);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Like {@link #disableCarrierAppsUntilPrivileged(String, TelephonyManager, int, Context)},
|
||
|
|
* but assumes that no carrier apps have carrier privileges.
|
||
|
|
*
|
||
|
|
* This prevents a potential race condition on first boot - since the app's default state is
|
||
|
|
* enabled, we will initially disable it when the telephony stack is first initialized as it has
|
||
|
|
* not yet read the carrier privilege rules. However, since telephony is initialized later on
|
||
|
|
* late in boot, the app being disabled may have already been started in response to certain
|
||
|
|
* broadcasts. The app will continue to run (briefly) after being disabled, before the Package
|
||
|
|
* Manager can kill it, and this can lead to crashes as the app is in an unexpected state.
|
||
|
|
*/
|
||
|
|
public static synchronized void disableCarrierAppsUntilPrivileged(String callingPackage,
|
||
|
|
@UserIdInt int userId, Context context) {
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, "disableCarrierAppsUntilPrivileged");
|
||
|
|
}
|
||
|
|
SystemConfigManager config = context.getSystemService(SystemConfigManager.class);
|
||
|
|
Set<String> systemCarrierAppsDisabledUntilUsed =
|
||
|
|
config.getDisabledUntilUsedPreinstalledCarrierApps();
|
||
|
|
|
||
|
|
Map<String, List<CarrierAssociatedAppEntry>> systemCarrierAssociatedAppsDisabledUntilUsed =
|
||
|
|
config.getDisabledUntilUsedPreinstalledCarrierAssociatedAppEntries();
|
||
|
|
ContentResolver contentResolver = getContentResolverForUser(context, userId);
|
||
|
|
disableCarrierAppsUntilPrivileged(callingPackage, null /* telephonyManager */,
|
||
|
|
contentResolver, userId, systemCarrierAppsDisabledUntilUsed,
|
||
|
|
systemCarrierAssociatedAppsDisabledUntilUsed, context);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static ContentResolver getContentResolverForUser(Context context,
|
||
|
|
@UserIdInt int userId) {
|
||
|
|
Context userContext = context.createContextAsUser(UserHandle.of(userId), 0);
|
||
|
|
return userContext.getContentResolver();
|
||
|
|
}
|
||
|
|
|
||
|
|
private static boolean isUpdatedSystemApp(ApplicationInfo ai) {
|
||
|
|
return (ai.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Disable carrier apps until they are privileged
|
||
|
|
* Must be public b/c framework unit tests can't access package-private methods.
|
||
|
|
*/
|
||
|
|
// Must be public b/c framework unit tests can't access package-private methods.
|
||
|
|
@VisibleForTesting
|
||
|
|
public static void disableCarrierAppsUntilPrivileged(String callingPackage,
|
||
|
|
@Nullable TelephonyManager telephonyManager, ContentResolver contentResolver,
|
||
|
|
int userId, Set<String> systemCarrierAppsDisabledUntilUsed,
|
||
|
|
Map<String, List<CarrierAssociatedAppEntry>>
|
||
|
|
systemCarrierAssociatedAppsDisabledUntilUsed, Context context) {
|
||
|
|
PackageManager packageManager = context.getPackageManager();
|
||
|
|
LegacyPermissionManager permissionManager = (LegacyPermissionManager)
|
||
|
|
context.getSystemService(Context.LEGACY_PERMISSION_SERVICE);
|
||
|
|
List<ApplicationInfo> candidates = getDefaultCarrierAppCandidatesHelper(
|
||
|
|
userId, systemCarrierAppsDisabledUntilUsed, context);
|
||
|
|
if (candidates == null || candidates.isEmpty()) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
Map<String, List<AssociatedAppInfo>> associatedApps = getDefaultCarrierAssociatedAppsHelper(
|
||
|
|
userId, systemCarrierAssociatedAppsDisabledUntilUsed, context);
|
||
|
|
|
||
|
|
List<String> enabledCarrierPackages = new ArrayList<>();
|
||
|
|
int carrierAppsHandledSdk =
|
||
|
|
Settings.Secure.getIntForUser(contentResolver, Settings.Secure.CARRIER_APPS_HANDLED,
|
||
|
|
0, contentResolver.getUserId());
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.i(TAG, "Last execution SDK: " + carrierAppsHandledSdk);
|
||
|
|
}
|
||
|
|
boolean hasRunEver = carrierAppsHandledSdk != 0; // SDKs < R used to just set 1 here
|
||
|
|
boolean hasRunForSdk = carrierAppsHandledSdk == Build.VERSION.SDK_INT;
|
||
|
|
|
||
|
|
try {
|
||
|
|
for (ApplicationInfo ai : candidates) {
|
||
|
|
String packageName = ai.packageName;
|
||
|
|
boolean hasPrivileges = telephonyManager != null
|
||
|
|
&& telephonyManager.checkCarrierPrivilegesForPackageAnyPhone(packageName)
|
||
|
|
== TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS;
|
||
|
|
|
||
|
|
// add hiddenUntilInstalled flag for carrier apps and associated apps
|
||
|
|
packageManager.setSystemAppState(
|
||
|
|
packageName, PackageManager.SYSTEM_APP_STATE_HIDDEN_UNTIL_INSTALLED_HIDDEN);
|
||
|
|
List<AssociatedAppInfo> associatedAppList = associatedApps.get(packageName);
|
||
|
|
if (associatedAppList != null) {
|
||
|
|
for (AssociatedAppInfo associatedApp : associatedAppList) {
|
||
|
|
packageManager.setSystemAppState(associatedApp.appInfo.packageName,
|
||
|
|
PackageManager.SYSTEM_APP_STATE_HIDDEN_UNTIL_INSTALLED_HIDDEN);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int enabledSetting = context.createContextAsUser(UserHandle.of(userId), 0)
|
||
|
|
.getPackageManager().getApplicationEnabledSetting(packageName);
|
||
|
|
if (hasPrivileges) {
|
||
|
|
// Only update enabled state for the app on /system. Once it has been
|
||
|
|
// updated we shouldn't touch it.
|
||
|
|
if (!isUpdatedSystemApp(ai) && enabledSetting
|
||
|
|
== PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
|
||
|
|
|| enabledSetting
|
||
|
|
== PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
|
||
|
|
|| (ai.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
|
||
|
|
Log.i(TAG, "Update state (" + packageName + "): ENABLED for user "
|
||
|
|
+ userId);
|
||
|
|
context.createContextAsUser(UserHandle.of(userId), 0)
|
||
|
|
.getPackageManager()
|
||
|
|
.setSystemAppState(
|
||
|
|
packageName, PackageManager.SYSTEM_APP_STATE_INSTALLED);
|
||
|
|
context.createPackageContextAsUser(callingPackage, 0, UserHandle.of(userId))
|
||
|
|
.getPackageManager()
|
||
|
|
.setApplicationEnabledSetting(
|
||
|
|
packageName,
|
||
|
|
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
|
||
|
|
PackageManager.DONT_KILL_APP);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Also enable any associated apps for this carrier app.
|
||
|
|
if (associatedAppList != null) {
|
||
|
|
for (AssociatedAppInfo associatedApp : associatedAppList) {
|
||
|
|
int associatedAppEnabledSetting = context
|
||
|
|
.createContextAsUser(UserHandle.of(userId), 0)
|
||
|
|
.getPackageManager()
|
||
|
|
.getApplicationEnabledSetting(
|
||
|
|
associatedApp.appInfo.packageName);
|
||
|
|
boolean associatedAppInstalled = (associatedApp.appInfo.flags
|
||
|
|
& ApplicationInfo.FLAG_INSTALLED) != 0;
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.i(TAG, "(hasPrivileges) associated app "
|
||
|
|
+ associatedApp.appInfo.packageName + ", enabled = "
|
||
|
|
+ associatedAppEnabledSetting + ", installed = "
|
||
|
|
+ associatedAppInstalled);
|
||
|
|
}
|
||
|
|
if (associatedAppEnabledSetting
|
||
|
|
== PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
|
||
|
|
|| associatedAppEnabledSetting
|
||
|
|
== PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
|
||
|
|
|| !associatedAppInstalled) {
|
||
|
|
Log.i(TAG, "Update associated state ("
|
||
|
|
+ associatedApp.appInfo.packageName + "): ENABLED for user "
|
||
|
|
+ userId);
|
||
|
|
context.createContextAsUser(UserHandle.of(userId), 0)
|
||
|
|
.getPackageManager()
|
||
|
|
.setSystemAppState(associatedApp.appInfo.packageName,
|
||
|
|
PackageManager.SYSTEM_APP_STATE_INSTALLED);
|
||
|
|
context.createPackageContextAsUser(
|
||
|
|
callingPackage, 0, UserHandle.of(userId))
|
||
|
|
.getPackageManager()
|
||
|
|
.setApplicationEnabledSetting(
|
||
|
|
associatedApp.appInfo.packageName,
|
||
|
|
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
|
||
|
|
PackageManager.DONT_KILL_APP);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Always re-grant default permissions to carrier apps w/ privileges.
|
||
|
|
enabledCarrierPackages.add(ai.packageName);
|
||
|
|
} else { // No carrier privileges
|
||
|
|
// Only uninstall system carrier apps that fulfill ALL conditions below:
|
||
|
|
// 1. It has no carrier privileges
|
||
|
|
// 2. It has never been uninstalled before (i.e. we uninstall at most once)
|
||
|
|
// 3. It has not been installed as an update from its system built-in version
|
||
|
|
// 4. It is in default state (not explicitly DISABLED/DISABLED_BY_USER/ENABLED)
|
||
|
|
// 5. It is currently installed for the calling user
|
||
|
|
// TODO(b/329739019):
|
||
|
|
// 1. Merge the nested if conditions below during flag cleaning up phase
|
||
|
|
// 2. Support user case that NEW carrier app is added during OTA, when emerge.
|
||
|
|
if (!Flags.hidePreinstalledCarrierAppAtMostOnce() || !hasRunEver) {
|
||
|
|
if (!isUpdatedSystemApp(ai) && enabledSetting
|
||
|
|
== PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
|
||
|
|
&& (ai.flags & ApplicationInfo.FLAG_INSTALLED) != 0) {
|
||
|
|
Log.i(TAG, "Update state (" + packageName
|
||
|
|
+ "): DISABLED_UNTIL_USED for user " + userId);
|
||
|
|
context.createContextAsUser(UserHandle.of(userId), 0)
|
||
|
|
.getPackageManager()
|
||
|
|
.setSystemAppState(
|
||
|
|
packageName,
|
||
|
|
PackageManager.SYSTEM_APP_STATE_UNINSTALLED);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Associated apps are more brittle, because we can't rely on the distinction
|
||
|
|
// between "default" and "enabled". To account for this, we have two cases:
|
||
|
|
// 1. We've never run before, so we're fine to disable all associated apps.
|
||
|
|
// 2. We've run before, but not on this SDK version, so we will only operate on
|
||
|
|
// apps with addedInSdk in the range (lastHandledSdk, currentSdk].
|
||
|
|
// Otherwise, don't touch the associated apps.
|
||
|
|
if (associatedAppList != null) {
|
||
|
|
for (AssociatedAppInfo associatedApp : associatedAppList) {
|
||
|
|
boolean allowDisable = !hasRunEver || (!hasRunForSdk
|
||
|
|
&& associatedApp.addedInSdk
|
||
|
|
!= CarrierAssociatedAppEntry.SDK_UNSPECIFIED
|
||
|
|
&& associatedApp.addedInSdk > carrierAppsHandledSdk
|
||
|
|
&& associatedApp.addedInSdk <= Build.VERSION.SDK_INT);
|
||
|
|
int associatedAppEnabledSetting = context
|
||
|
|
.createContextAsUser(UserHandle.of(userId), 0)
|
||
|
|
.getPackageManager()
|
||
|
|
.getApplicationEnabledSetting(
|
||
|
|
associatedApp.appInfo.packageName);
|
||
|
|
boolean associatedAppInstalled = (associatedApp.appInfo.flags
|
||
|
|
& ApplicationInfo.FLAG_INSTALLED) != 0;
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.i(TAG, "(!hasPrivileges) associated app "
|
||
|
|
+ associatedApp.appInfo.packageName + ", allowDisable = "
|
||
|
|
+ allowDisable + ", addedInSdk = "
|
||
|
|
+ associatedApp.addedInSdk + ", enabled = "
|
||
|
|
+ associatedAppEnabledSetting + ", installed = "
|
||
|
|
+ associatedAppInstalled);
|
||
|
|
}
|
||
|
|
if (allowDisable
|
||
|
|
&& associatedAppEnabledSetting
|
||
|
|
== PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
|
||
|
|
&& associatedAppInstalled) {
|
||
|
|
Log.i(TAG,
|
||
|
|
"Update associated state ("
|
||
|
|
+ associatedApp.appInfo.packageName
|
||
|
|
+ "): DISABLED_UNTIL_USED for user " + userId);
|
||
|
|
context.createContextAsUser(UserHandle.of(userId), 0)
|
||
|
|
.getPackageManager()
|
||
|
|
.setSystemAppState(associatedApp.appInfo.packageName,
|
||
|
|
PackageManager.SYSTEM_APP_STATE_UNINSTALLED);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Mark the execution so we do not disable apps again on this SDK version.
|
||
|
|
if (!hasRunEver || !hasRunForSdk) {
|
||
|
|
Settings.Secure.putIntForUser(contentResolver, Settings.Secure.CARRIER_APPS_HANDLED,
|
||
|
|
Build.VERSION.SDK_INT, contentResolver.getUserId());
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!enabledCarrierPackages.isEmpty()) {
|
||
|
|
// Since we enabled at least one app, ensure we grant default permissions to those
|
||
|
|
// apps.
|
||
|
|
String[] packageNames = new String[enabledCarrierPackages.size()];
|
||
|
|
enabledCarrierPackages.toArray(packageNames);
|
||
|
|
permissionManager.grantDefaultPermissionsToEnabledCarrierApps(packageNames,
|
||
|
|
UserHandle.of(userId), TelephonyUtils.DIRECT_EXECUTOR, isSuccess -> { });
|
||
|
|
}
|
||
|
|
} catch (PackageManager.NameNotFoundException e) {
|
||
|
|
Log.w(TAG, "Could not reach PackageManager", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the list of "default" carrier apps.
|
||
|
|
*
|
||
|
|
* This is the subset of apps returned by
|
||
|
|
* {@link #getDefaultCarrierAppCandidates(int, Context)} which currently have carrier
|
||
|
|
* privileges per the SIM(s) inserted in the device.
|
||
|
|
*/
|
||
|
|
public static List<ApplicationInfo> getDefaultCarrierApps(
|
||
|
|
TelephonyManager telephonyManager, int userId, Context context) {
|
||
|
|
// Get all system apps from the default list.
|
||
|
|
List<ApplicationInfo> candidates = getDefaultCarrierAppCandidates(userId, context);
|
||
|
|
if (candidates == null || candidates.isEmpty()) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Filter out apps without carrier privileges.
|
||
|
|
// Iterate from the end to avoid creating an Iterator object and because we will be removing
|
||
|
|
// elements from the list as we pass through it.
|
||
|
|
for (int i = candidates.size() - 1; i >= 0; i--) {
|
||
|
|
ApplicationInfo ai = candidates.get(i);
|
||
|
|
String packageName = ai.packageName;
|
||
|
|
boolean hasPrivileges =
|
||
|
|
telephonyManager.checkCarrierPrivilegesForPackageAnyPhone(packageName)
|
||
|
|
== TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS;
|
||
|
|
if (!hasPrivileges) {
|
||
|
|
candidates.remove(i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return candidates;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the list of "default" carrier app candidates.
|
||
|
|
*
|
||
|
|
* These are the apps subject to the hiding/showing logic in
|
||
|
|
* {@link CarrierAppUtils#disableCarrierAppsUntilPrivileged(String, TelephonyManager, int,
|
||
|
|
* Context)}, as well as the apps which should have default
|
||
|
|
* permissions granted, when a matching SIM is inserted.
|
||
|
|
*
|
||
|
|
* Whether or not the app is actually considered a default app depends on whether the app has
|
||
|
|
* carrier privileges as determined by the SIMs in the device.
|
||
|
|
*/
|
||
|
|
public static List<ApplicationInfo> getDefaultCarrierAppCandidates(
|
||
|
|
int userId, Context context) {
|
||
|
|
Set<String> systemCarrierAppsDisabledUntilUsed =
|
||
|
|
context.getSystemService(SystemConfigManager.class)
|
||
|
|
.getDisabledUntilUsedPreinstalledCarrierApps();
|
||
|
|
return getDefaultCarrierAppCandidatesHelper(userId, systemCarrierAppsDisabledUntilUsed,
|
||
|
|
context);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static List<ApplicationInfo> getDefaultCarrierAppCandidatesHelper(
|
||
|
|
int userId, Set<String> systemCarrierAppsDisabledUntilUsed, Context context) {
|
||
|
|
if (systemCarrierAppsDisabledUntilUsed == null
|
||
|
|
|| systemCarrierAppsDisabledUntilUsed.isEmpty()) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
List<ApplicationInfo> apps = new ArrayList<>(systemCarrierAppsDisabledUntilUsed.size());
|
||
|
|
for (String packageName : systemCarrierAppsDisabledUntilUsed) {
|
||
|
|
ApplicationInfo ai =
|
||
|
|
getApplicationInfoIfSystemApp(userId, packageName, context);
|
||
|
|
if (ai != null) {
|
||
|
|
apps.add(ai);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return apps;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Map<String, List<AssociatedAppInfo>> getDefaultCarrierAssociatedAppsHelper(
|
||
|
|
int userId, Map<String, List<CarrierAssociatedAppEntry>>
|
||
|
|
systemCarrierAssociatedAppsDisabledUntilUsed, Context context) {
|
||
|
|
int size = systemCarrierAssociatedAppsDisabledUntilUsed.size();
|
||
|
|
Map<String, List<AssociatedAppInfo>> associatedApps = new ArrayMap<>(size);
|
||
|
|
for (Map.Entry<String, List<CarrierAssociatedAppEntry>> entry
|
||
|
|
: systemCarrierAssociatedAppsDisabledUntilUsed.entrySet()) {
|
||
|
|
String carrierAppPackage = entry.getKey();
|
||
|
|
List<CarrierAssociatedAppEntry> associatedAppPackages = entry.getValue();
|
||
|
|
for (int j = 0; j < associatedAppPackages.size(); j++) {
|
||
|
|
CarrierAssociatedAppEntry associatedApp = associatedAppPackages.get(j);
|
||
|
|
ApplicationInfo ai =
|
||
|
|
getApplicationInfoIfSystemApp(userId, associatedApp.packageName, context);
|
||
|
|
// Only update enabled state for the app on /system. Once it has been updated we
|
||
|
|
// shouldn't touch it.
|
||
|
|
if (ai != null && !isUpdatedSystemApp(ai)) {
|
||
|
|
List<AssociatedAppInfo> appList = associatedApps.get(carrierAppPackage);
|
||
|
|
if (appList == null) {
|
||
|
|
appList = new ArrayList<>();
|
||
|
|
associatedApps.put(carrierAppPackage, appList);
|
||
|
|
}
|
||
|
|
appList.add(new AssociatedAppInfo(ai, associatedApp.addedInSdk));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return associatedApps;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Nullable
|
||
|
|
private static ApplicationInfo getApplicationInfoIfSystemApp(
|
||
|
|
int userId, String packageName, Context context) {
|
||
|
|
try {
|
||
|
|
ApplicationInfo ai = context.createContextAsUser(UserHandle.of(userId), 0)
|
||
|
|
.getPackageManager()
|
||
|
|
.getApplicationInfo(packageName,
|
||
|
|
PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
|
||
|
|
| PackageManager.MATCH_HIDDEN_UNTIL_INSTALLED_COMPONENTS
|
||
|
|
| PackageManager.MATCH_SYSTEM_ONLY);
|
||
|
|
if (ai != null) {
|
||
|
|
return ai;
|
||
|
|
}
|
||
|
|
} catch (PackageManager.NameNotFoundException e) {
|
||
|
|
Log.w(TAG, "Could not reach PackageManager", e);
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final class AssociatedAppInfo {
|
||
|
|
public final ApplicationInfo appInfo;
|
||
|
|
// Might be CarrierAssociatedAppEntry.SDK_UNSPECIFIED.
|
||
|
|
public final int addedInSdk;
|
||
|
|
|
||
|
|
AssociatedAppInfo(ApplicationInfo appInfo, int addedInSdk) {
|
||
|
|
this.appInfo = appInfo;
|
||
|
|
this.addedInSdk = addedInSdk;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|