Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Synchronize managed services approval list" into qt-qpr1-dev

Browse Source
This commit is contained in:
TreeHugger Robot
2019-07-29 04:50:10 +00:00
committed by Android (Google) Code Review
parent a754ff1066 77f1e4d018
commit 4091b07fe8
1 changed files with 204 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

376
services/core/java/com/android/server/notification/ManagedServices.java
View File

@@ -196,18 +196,20 @@ abstract public class ManagedServices {
public void dump(PrintWriter pw, DumpFilter filter) { public void dump(PrintWriter pw, DumpFilter filter) {
pw.println(" Allowed " + getCaption() + "s:"); pw.println(" Allowed " + getCaption() + "s:");
final int N = mApproved.size(); synchronized (mApproved) {
for (int i = 0 ; i < N; i++) { final int N = mApproved.size();
final int userId = mApproved.keyAt(i); for (int i = 0; i < N; i++) {
final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.valueAt(i); final int userId = mApproved.keyAt(i);
if (approvedByType != null) { final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.valueAt(i);
final int M = approvedByType.size(); if (approvedByType != null) {
for (int j = 0; j < M; j++) { final int M = approvedByType.size();
final boolean isPrimary = approvedByType.keyAt(j); for (int j = 0; j < M; j++) {
final ArraySet<String> approved = approvedByType.valueAt(j); final boolean isPrimary = approvedByType.keyAt(j);
if (approvedByType != null && approvedByType.size() > 0) { final ArraySet<String> approved = approvedByType.valueAt(j);
pw.println(" " + String.join(ENABLED_SERVICES_SEPARATOR, approved) if (approvedByType != null && approvedByType.size() > 0) {
+ " (user: " + userId + " isPrimary: " + isPrimary + ")"); pw.println(" " + String.join(ENABLED_SERVICES_SEPARATOR, approved)
+ " (user: " + userId + " isPrimary: " + isPrimary + ")");
}
} }
} }
} }
@@ -240,23 +242,25 @@ abstract public class ManagedServices {
public void dump(ProtoOutputStream proto, DumpFilter filter) { public void dump(ProtoOutputStream proto, DumpFilter filter) {
proto.write(ManagedServicesProto.CAPTION, getCaption()); proto.write(ManagedServicesProto.CAPTION, getCaption());
final int N = mApproved.size(); synchronized (mApproved) {
for (int i = 0 ; i < N; i++) { final int N = mApproved.size();
final int userId = mApproved.keyAt(i); for (int i = 0; i < N; i++) {
final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.valueAt(i); final int userId = mApproved.keyAt(i);
if (approvedByType != null) { final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.valueAt(i);
final int M = approvedByType.size(); if (approvedByType != null) {
for (int j = 0; j < M; j++) { final int M = approvedByType.size();
final boolean isPrimary = approvedByType.keyAt(j); for (int j = 0; j < M; j++) {
final ArraySet<String> approved = approvedByType.valueAt(j); final boolean isPrimary = approvedByType.keyAt(j);
if (approvedByType != null && approvedByType.size() > 0) { final ArraySet<String> approved = approvedByType.valueAt(j);
final long sToken = proto.start(ManagedServicesProto.APPROVED); if (approvedByType != null && approvedByType.size() > 0) {
for (String s : approved) { final long sToken = proto.start(ManagedServicesProto.APPROVED);
proto.write(ServiceProto.NAME, s); for (String s : approved) {
proto.write(ServiceProto.NAME, s);
}
proto.write(ServiceProto.USER_ID, userId);
proto.write(ServiceProto.IS_PRIMARY, isPrimary);
proto.end(sToken);
} }
proto.write(ServiceProto.USER_ID, userId);
proto.write(ServiceProto.IS_PRIMARY, isPrimary);
proto.end(sToken);
} }
} }
} }
@@ -315,33 +319,36 @@ abstract public class ManagedServices {
trimApprovedListsAccordingToInstalledServices(userId); trimApprovedListsAccordingToInstalledServices(userId);
} }
final int N = mApproved.size(); synchronized (mApproved) {
for (int i = 0 ; i < N; i++) { final int N = mApproved.size();
final int approvedUserId = mApproved.keyAt(i); for (int i = 0; i < N; i++) {
if (forBackup && approvedUserId != userId) { final int approvedUserId = mApproved.keyAt(i);
continue; if (forBackup && approvedUserId != userId) {
} continue;
final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.valueAt(i); }
if (approvedByType != null) { final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.valueAt(i);
final int M = approvedByType.size(); if (approvedByType != null) {
for (int j = 0; j < M; j++) { final int M = approvedByType.size();
final boolean isPrimary = approvedByType.keyAt(j); for (int j = 0; j < M; j++) {
final Set<String> approved = approvedByType.valueAt(j); final boolean isPrimary = approvedByType.keyAt(j);
if (approved != null) { final Set<String> approved = approvedByType.valueAt(j);
String allowedItems = String.join(ENABLED_SERVICES_SEPARATOR, approved); if (approved != null) {
out.startTag(null, TAG_MANAGED_SERVICES); String allowedItems = String.join(ENABLED_SERVICES_SEPARATOR, approved);
out.attribute(null, ATT_APPROVED_LIST, allowedItems); out.startTag(null, TAG_MANAGED_SERVICES);
out.attribute(null, ATT_USER_ID, Integer.toString(approvedUserId)); out.attribute(null, ATT_APPROVED_LIST, allowedItems);
out.attribute(null, ATT_IS_PRIMARY, Boolean.toString(isPrimary)); out.attribute(null, ATT_USER_ID, Integer.toString(approvedUserId));
writeExtraAttributes(out, approvedUserId); out.attribute(null, ATT_IS_PRIMARY, Boolean.toString(isPrimary));
out.endTag(null, TAG_MANAGED_SERVICES); writeExtraAttributes(out, approvedUserId);
out.endTag(null, TAG_MANAGED_SERVICES);
if (!forBackup && isPrimary) {
// Also write values to settings, for observers who haven't migrated yet
Settings.Secure.putStringForUser(mContext.getContentResolver(),
getConfig().secureSettingName, allowedItems,
approvedUserId);
}
if (!forBackup && isPrimary) {
// Also write values to settings, for observers who haven't migrated yet
Settings.Secure.putStringForUser(mContext.getContentResolver(),
getConfig().secureSettingName, allowedItems, approvedUserId);
} }
} }
} }
} }
@@ -440,23 +447,25 @@ abstract public class ManagedServices {
if (TextUtils.isEmpty(approved)) { if (TextUtils.isEmpty(approved)) {
approved = ""; approved = "";
} }
ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.get(userId); synchronized (mApproved) {
if (approvedByType == null) { ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.get(userId);
approvedByType = new ArrayMap<>(); if (approvedByType == null) {
mApproved.put(userId, approvedByType); approvedByType = new ArrayMap<>();
} mApproved.put(userId, approvedByType);
}
ArraySet<String> approvedList = approvedByType.get(isPrimary); ArraySet<String> approvedList = approvedByType.get(isPrimary);
if (approvedList == null) { if (approvedList == null) {
approvedList = new ArraySet<>(); approvedList = new ArraySet<>();
approvedByType.put(isPrimary, approvedList); approvedByType.put(isPrimary, approvedList);
} }
String[] approvedArray = approved.split(ENABLED_SERVICES_SEPARATOR); String[] approvedArray = approved.split(ENABLED_SERVICES_SEPARATOR);
for (String pkgOrComponent : approvedArray) { for (String pkgOrComponent : approvedArray) {
String approvedItem = getApprovedValue(pkgOrComponent); String approvedItem = getApprovedValue(pkgOrComponent);
if (approvedItem != null) { if (approvedItem != null) {
approvedList.add(approvedItem); approvedList.add(approvedItem);
}
} }
} }
} }
@@ -469,23 +478,25 @@ abstract public class ManagedServices {
boolean isPrimary, boolean enabled) { boolean isPrimary, boolean enabled) {
Slog.i(TAG, Slog.i(TAG,
(enabled ? " Allowing " : "Disallowing ") + mConfig.caption + " " + pkgOrComponent); (enabled ? " Allowing " : "Disallowing ") + mConfig.caption + " " + pkgOrComponent);
ArrayMap<Boolean, ArraySet<String>> allowedByType = mApproved.get(userId); synchronized (mApproved) {
if (allowedByType == null) { ArrayMap<Boolean, ArraySet<String>> allowedByType = mApproved.get(userId);
allowedByType = new ArrayMap<>(); if (allowedByType == null) {
mApproved.put(userId, allowedByType); allowedByType = new ArrayMap<>();
} mApproved.put(userId, allowedByType);
ArraySet<String> approved = allowedByType.get(isPrimary); }
if (approved == null) { ArraySet<String> approved = allowedByType.get(isPrimary);
approved = new ArraySet<>(); if (approved == null) {
allowedByType.put(isPrimary, approved); approved = new ArraySet<>();
} allowedByType.put(isPrimary, approved);
String approvedItem = getApprovedValue(pkgOrComponent); }
String approvedItem = getApprovedValue(pkgOrComponent);
if (approvedItem != null) { if (approvedItem != null) {
if (enabled) { if (enabled) {
approved.add(approvedItem); approved.add(approvedItem);
} else { } else {
approved.remove(approvedItem); approved.remove(approvedItem);
}
} }
} }
@@ -504,22 +515,26 @@ abstract public class ManagedServices {
} }
protected String getApproved(int userId, boolean primary) { protected String getApproved(int userId, boolean primary) {
final ArrayMap<Boolean, ArraySet<String>> allowedByType = synchronized (mApproved) {
mApproved.getOrDefault(userId, new ArrayMap<>()); final ArrayMap<Boolean, ArraySet<String>> allowedByType =
ArraySet<String> approved = allowedByType.getOrDefault(primary, new ArraySet<>()); mApproved.getOrDefault(userId, new ArrayMap<>());
return String.join(ENABLED_SERVICES_SEPARATOR, approved); ArraySet<String> approved = allowedByType.getOrDefault(primary, new ArraySet<>());
return String.join(ENABLED_SERVICES_SEPARATOR, approved);
}
} }
protected List<ComponentName> getAllowedComponents(int userId) { protected List<ComponentName> getAllowedComponents(int userId) {
final List<ComponentName> allowedComponents = new ArrayList<>(); final List<ComponentName> allowedComponents = new ArrayList<>();
final ArrayMap<Boolean, ArraySet<String>> allowedByType = synchronized (mApproved) {
mApproved.getOrDefault(userId, new ArrayMap<>()); final ArrayMap<Boolean, ArraySet<String>> allowedByType =
for (int i = 0; i < allowedByType.size(); i++) { mApproved.getOrDefault(userId, new ArrayMap<>());
final ArraySet<String> allowed = allowedByType.valueAt(i); for (int i = 0; i < allowedByType.size(); i++) {
for (int j = 0; j < allowed.size(); j++) { final ArraySet<String> allowed = allowedByType.valueAt(i);
ComponentName cn = ComponentName.unflattenFromString(allowed.valueAt(j)); for (int j = 0; j < allowed.size(); j++) {
if (cn != null) { ComponentName cn = ComponentName.unflattenFromString(allowed.valueAt(j));
allowedComponents.add(cn); if (cn != null) {
allowedComponents.add(cn);
}
} }
} }
} }
@@ -528,14 +543,16 @@ abstract public class ManagedServices {
protected List<String> getAllowedPackages(int userId) { protected List<String> getAllowedPackages(int userId) {
final List<String> allowedPackages = new ArrayList<>(); final List<String> allowedPackages = new ArrayList<>();
final ArrayMap<Boolean, ArraySet<String>> allowedByType = synchronized (mApproved) {
mApproved.getOrDefault(userId, new ArrayMap<>()); final ArrayMap<Boolean, ArraySet<String>> allowedByType =
for (int i = 0; i < allowedByType.size(); i++) { mApproved.getOrDefault(userId, new ArrayMap<>());
final ArraySet<String> allowed = allowedByType.valueAt(i); for (int i = 0; i < allowedByType.size(); i++) {
for (int j = 0; j < allowed.size(); j++) { final ArraySet<String> allowed = allowedByType.valueAt(i);
String pkgName = getPackageName(allowed.valueAt(j)); for (int j = 0; j < allowed.size(); j++) {
if (!TextUtils.isEmpty(pkgName)) { String pkgName = getPackageName(allowed.valueAt(j));
allowedPackages.add(pkgName); if (!TextUtils.isEmpty(pkgName)) {
allowedPackages.add(pkgName);
}
} }
} }
} }
@@ -543,12 +560,14 @@ abstract public class ManagedServices {
} }
protected boolean isPackageOrComponentAllowed(String pkgOrComponent, int userId) { protected boolean isPackageOrComponentAllowed(String pkgOrComponent, int userId) {
ArrayMap<Boolean, ArraySet<String>> allowedByType = synchronized (mApproved) {
mApproved.getOrDefault(userId, new ArrayMap<>()); ArrayMap<Boolean, ArraySet<String>> allowedByType =
for (int i = 0; i < allowedByType.size(); i++) { mApproved.getOrDefault(userId, new ArrayMap<>());
ArraySet<String> allowed = allowedByType.valueAt(i); for (int i = 0; i < allowedByType.size(); i++) {
if (allowed.contains(pkgOrComponent)) { ArraySet<String> allowed = allowedByType.valueAt(i);
return true; if (allowed.contains(pkgOrComponent)) {
return true;
}
} }
} }
return false; return false;
@@ -558,19 +577,21 @@ abstract public class ManagedServices {
if (pkg == null) { if (pkg == null) {
return false; return false;
} }
ArrayMap<Boolean, ArraySet<String>> allowedByType = synchronized (mApproved) {
mApproved.getOrDefault(userId, new ArrayMap<>()); ArrayMap<Boolean, ArraySet<String>> allowedByType =
for (int i = 0; i < allowedByType.size(); i++) { mApproved.getOrDefault(userId, new ArrayMap<>());
ArraySet<String> allowed = allowedByType.valueAt(i); for (int i = 0; i < allowedByType.size(); i++) {
for (String allowedEntry : allowed) { ArraySet<String> allowed = allowedByType.valueAt(i);
ComponentName component = ComponentName.unflattenFromString(allowedEntry); for (String allowedEntry : allowed) {
if (component != null) { ComponentName component = ComponentName.unflattenFromString(allowedEntry);
if (pkg.equals(component.getPackageName())) { if (component != null) {
return true; if (pkg.equals(component.getPackageName())) {
} return true;
} else { }
if (pkg.equals(allowedEntry)) { } else {
return true; if (pkg.equals(allowedEntry)) {
return true;
}
} }
} }
} }
@@ -616,7 +637,9 @@ abstract public class ManagedServices {
public void onUserRemoved(int user) { public void onUserRemoved(int user) {
Slog.i(TAG, "Removing approved services for removed user " + user); Slog.i(TAG, "Removing approved services for removed user " + user);
mApproved.remove(user); synchronized (mApproved) {
mApproved.remove(user);
}
rebindServices(true, user); rebindServices(true, user);
} }
@@ -797,14 +820,16 @@ abstract public class ManagedServices {
protected Set<String> getAllowedPackages() { protected Set<String> getAllowedPackages() {
final Set<String> allowedPackages = new ArraySet<>(); final Set<String> allowedPackages = new ArraySet<>();
for (int k = 0; k < mApproved.size(); k++) { synchronized (mApproved) {
ArrayMap<Boolean, ArraySet<String>> allowedByType = mApproved.valueAt(k); for (int k = 0; k < mApproved.size(); k++) {
for (int i = 0; i < allowedByType.size(); i++) { ArrayMap<Boolean, ArraySet<String>> allowedByType = mApproved.valueAt(k);
final ArraySet<String> allowed = allowedByType.valueAt(i); for (int i = 0; i < allowedByType.size(); i++) {
for (int j = 0; j < allowed.size(); j++) { final ArraySet<String> allowed = allowedByType.valueAt(i);
String pkgName = getPackageName(allowed.valueAt(j)); for (int j = 0; j < allowed.size(); j++) {
if (!TextUtils.isEmpty(pkgName)) { String pkgName = getPackageName(allowed.valueAt(j));
allowedPackages.add(pkgName); if (!TextUtils.isEmpty(pkgName)) {
allowedPackages.add(pkgName);
}
} }
} }
} }
@@ -813,22 +838,24 @@ abstract public class ManagedServices {
} }
private void trimApprovedListsAccordingToInstalledServices(int userId) { private void trimApprovedListsAccordingToInstalledServices(int userId) {
final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.get(userId); synchronized (mApproved) {
if (approvedByType == null) { final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.get(userId);
return; if (approvedByType == null) {
} return;
for (int i = 0; i < approvedByType.size(); i++) { }
final ArraySet<String> approved = approvedByType.valueAt(i); for (int i = 0; i < approvedByType.size(); i++) {
for (int j = approved.size() - 1; j >= 0; j--) { final ArraySet<String> approved = approvedByType.valueAt(i);
final String approvedPackageOrComponent = approved.valueAt(j); for (int j = approved.size() - 1; j >= 0; j--) {
if (!isValidEntry(approvedPackageOrComponent, userId)){ final String approvedPackageOrComponent = approved.valueAt(j);
approved.removeAt(j); if (!isValidEntry(approvedPackageOrComponent, userId)) {
Slog.v(TAG, "Removing " + approvedPackageOrComponent approved.removeAt(j);
+ " from approved list; no matching services found"); Slog.v(TAG, "Removing " + approvedPackageOrComponent
} else { + " from approved list; no matching services found");
if (DEBUG) { } else {
Slog.v(TAG, "Keeping " + approvedPackageOrComponent if (DEBUG) {
+ " on approved list; matching services found"); Slog.v(TAG, "Keeping " + approvedPackageOrComponent
+ " on approved list; matching services found");
}
} }
} }
} }
@@ -837,20 +864,23 @@ abstract public class ManagedServices {
private boolean removeUninstalledItemsFromApprovedLists(int uninstalledUserId, String pkg) { private boolean removeUninstalledItemsFromApprovedLists(int uninstalledUserId, String pkg) {
boolean removed = false; boolean removed = false;
final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.get(uninstalledUserId); synchronized (mApproved) {
if (approvedByType != null) { final ArrayMap<Boolean, ArraySet<String>> approvedByType = mApproved.get(
int M = approvedByType.size(); uninstalledUserId);
for (int j = 0; j < M; j++) { if (approvedByType != null) {
final ArraySet<String> approved = approvedByType.valueAt(j); int M = approvedByType.size();
int O = approved.size(); for (int j = 0; j < M; j++) {
for (int k = O - 1; k >= 0; k--) { final ArraySet<String> approved = approvedByType.valueAt(j);
final String packageOrComponent = approved.valueAt(k); int O = approved.size();
final String packageName = getPackageName(packageOrComponent); for (int k = O - 1; k >= 0; k--) {
if (TextUtils.equals(pkg, packageName)) { final String packageOrComponent = approved.valueAt(k);
approved.removeAt(k); final String packageName = getPackageName(packageOrComponent);
if (DEBUG) { if (TextUtils.equals(pkg, packageName)) {
Slog.v(TAG, "Removing " + packageOrComponent approved.removeAt(k);
+ " from approved list; uninstalled"); if (DEBUG) {
Slog.v(TAG, "Removing " + packageOrComponent
+ " from approved list; uninstalled");
}
} }
} }
} }
@@ -887,17 +917,19 @@ abstract public class ManagedServices {
for (int i = 0; i < nUserIds; ++i) { for (int i = 0; i < nUserIds; ++i) {
final int userId = userIds.get(i); final int userId = userIds.get(i);
final ArrayMap<Boolean, ArraySet<String>> approvedLists = mApproved.get(userId); synchronized (mApproved) {
if (approvedLists != null) { final ArrayMap<Boolean, ArraySet<String>> approvedLists = mApproved.get(userId);
final int N = approvedLists.size(); if (approvedLists != null) {
for (int j = 0; j < N; j++) { final int N = approvedLists.size();
ArraySet<ComponentName> approvedByUser = componentsByUser.get(userId); for (int j = 0; j < N; j++) {
if (approvedByUser == null) { ArraySet<ComponentName> approvedByUser = componentsByUser.get(userId);
approvedByUser = new ArraySet<>(); if (approvedByUser == null) {
componentsByUser.put(userId, approvedByUser); approvedByUser = new ArraySet<>();
componentsByUser.put(userId, approvedByUser);
}
approvedByUser.addAll(
loadComponentNamesFromValues(approvedLists.valueAt(j), userId));
} }
approvedByUser.addAll(
loadComponentNamesFromValues(approvedLists.valueAt(j), userId));
} }
} }
} }