Subclasses of this service are just a facade for the service binder calls - the "real" work * is done by the {@link AbstractPerUserSystemService} subclasses, which are automatically managed * through an user -> service cache. * *
It also takes care of other plumbing tasks such as: * *
See {@code com.android.server.autofill.AutofillManagerService} for a concrete
* (no pun intended) example of how to use it.
*
* @param This does not immediately recreate these services. It is assumed they will be recreated
* for the next user request.
*/
public static final int PACKAGE_UPDATE_POLICY_REFRESH_LAZY = 0x00000002;
/**
* On a package update, removes and recreates any existing per-user services in the cache.
*/
public static final int PACKAGE_UPDATE_POLICY_REFRESH_EAGER = 0x00000004;
/** On a package restart, does not refresh the per-user service in the cache. */
public static final int PACKAGE_RESTART_POLICY_NO_REFRESH = 0x00000010;
/**
* On a package restart, removes any existing per-user services in the cache.
*
* This does not immediately recreate these services. It is assumed they will be recreated
* for the next user request.
*/
public static final int PACKAGE_RESTART_POLICY_REFRESH_LAZY = 0x00000020;
/**
* On a package restart, removes and recreates any existing per-user services in the cache.
*/
public static final int PACKAGE_RESTART_POLICY_REFRESH_EAGER = 0x00000040;
@IntDef(flag = true, prefix = { "PACKAGE_" }, value = {
PACKAGE_UPDATE_POLICY_NO_REFRESH,
PACKAGE_UPDATE_POLICY_REFRESH_LAZY,
PACKAGE_UPDATE_POLICY_REFRESH_EAGER,
PACKAGE_RESTART_POLICY_NO_REFRESH,
PACKAGE_RESTART_POLICY_REFRESH_LAZY,
PACKAGE_RESTART_POLICY_REFRESH_EAGER
})
@Retention(RetentionPolicy.SOURCE)
public @interface ServicePackagePolicyFlags {}
/**
* Log tag
*/
protected final String mTag = getClass().getSimpleName();
/**
* Lock used to synchronize access to internal state; should be acquired before calling a
* method whose name ends with {@code locked}.
*/
protected final Object mLock = new Object();
/**
* Object used to define the name of the service component used to create
* {@link com.android.internal.infra.AbstractRemoteService} instances.
*/
@Nullable
protected final ServiceNameResolver mServiceNameResolver;
/**
* Whether the service should log debug statements.
*/
//TODO(b/117779333): consider using constants for these guards
public boolean verbose = false;
/**
* Whether the service should log verbose statements.
*/
//TODO(b/117779333): consider using constants for these guards
public boolean debug = false;
/**
* Whether the service is allowed to bind to an instant-app.
*/
@GuardedBy("mLock")
protected boolean mAllowInstantService;
/**
* Users disabled due to {@link UserManager} restrictions, or {@code null} if the service cannot
* be disabled through {@link UserManager}.
*/
@GuardedBy("mLock")
@Nullable
private final SparseBooleanArray mDisabledByUserRestriction;
/**
* Cache of service list per user id.
*/
@GuardedBy("mLock")
private final SparseArray When using this constructor, the {@link AbstractPerUserSystemService} is removed from
* the cache (and re-added) when the service package is updated.
*
* @param context system context.
* @param serviceNameResolver resolver for
* {@link com.android.internal.infra.AbstractRemoteService} instances, or
* {@code null} when the service doesn't bind to remote services.
* @param disallowProperty when not {@code null}, defines a {@link UserManager} restriction that
* disables the service. NOTE: you'll also need to add it to
* {@code UserRestrictionsUtils.USER_RESTRICTIONS}.
*/
protected AbstractMasterSystemService(@NonNull Context context,
@Nullable ServiceNameResolver serviceNameResolver,
@Nullable String disallowProperty) {
this(context, serviceNameResolver, disallowProperty,
PACKAGE_UPDATE_POLICY_REFRESH_LAZY | PACKAGE_RESTART_POLICY_REFRESH_LAZY);
}
/**
* Full Constructor.
*
* @param context system context.
* @param serviceNameResolver resolver for
* {@link com.android.internal.infra.AbstractRemoteService} instances, or
* {@code null} when the service doesn't bind to remote services.
* @param disallowProperty when not {@code null}, defines a {@link UserManager} restriction that
* disables the service. NOTE: you'll also need to add it to
* {@code UserRestrictionsUtils.USER_RESTRICTIONS}.
* @param servicePackagePolicyFlags a combination of
* {@link #PACKAGE_UPDATE_POLICY_NO_REFRESH},
* {@link #PACKAGE_UPDATE_POLICY_REFRESH_LAZY},
* {@link #PACKAGE_UPDATE_POLICY_REFRESH_EAGER},
* {@link #PACKAGE_RESTART_POLICY_NO_REFRESH},
* {@link #PACKAGE_RESTART_POLICY_REFRESH_LAZY} or
* {@link #PACKAGE_RESTART_POLICY_REFRESH_EAGER}
*/
protected AbstractMasterSystemService(@NonNull Context context,
@Nullable ServiceNameResolver serviceNameResolver, @Nullable String disallowProperty,
@ServicePackagePolicyFlags int servicePackagePolicyFlags) {
super(context);
final int updatePolicyMask = PACKAGE_UPDATE_POLICY_NO_REFRESH
| PACKAGE_UPDATE_POLICY_REFRESH_LAZY | PACKAGE_UPDATE_POLICY_REFRESH_EAGER;
if ((servicePackagePolicyFlags & updatePolicyMask) == 0) {
// If the package update policy is not set, add the default flag
servicePackagePolicyFlags |= PACKAGE_UPDATE_POLICY_REFRESH_LAZY;
}
final int restartPolicyMask = PACKAGE_RESTART_POLICY_NO_REFRESH
| PACKAGE_RESTART_POLICY_REFRESH_LAZY | PACKAGE_RESTART_POLICY_REFRESH_EAGER;
if ((servicePackagePolicyFlags & restartPolicyMask) == 0) {
// If the package restart policy is not set, add the default flag
servicePackagePolicyFlags |= PACKAGE_RESTART_POLICY_REFRESH_LAZY;
}
mServicePackagePolicyFlags = servicePackagePolicyFlags;
mServiceNameResolver = serviceNameResolver;
if (mServiceNameResolver != null) {
mServiceNameResolver.setOnTemporaryServiceNameChangedCallback(
this::onServiceNameChanged);
}
if (disallowProperty == null) {
mDisabledByUserRestriction = null;
} else {
mDisabledByUserRestriction = new SparseBooleanArray();
// Hookup with UserManager to disable service when necessary.
final UserManagerInternal umi = getUserManagerInternal();
final List Typically called by {@code ShellCommand} during CTS tests.
*
* @throws SecurityException if caller is not allowed to manage this service's settings.
*/
public final boolean getAllowInstantService() {
enforceCallingPermissionForManagement();
synchronized (mLock) {
return mAllowInstantService;
}
}
/**
* Checks whether the service is allowed to bind to an instant-app.
*
* Typically called by subclasses when creating {@link AbstractRemoteService} instances.
*
* NOTE: must not be called by {@code ShellCommand} as it does not check for
* permission.
*/
public final boolean isBindInstantServiceAllowed() {
synchronized (mLock) {
return mAllowInstantService;
}
}
/**
* Sets whether the service is allowed to bind to an instant-app.
*
* Typically called by {@code ShellCommand} during CTS tests.
*
* @throws SecurityException if caller is not allowed to manage this service's settings.
*/
public final void setAllowInstantService(boolean mode) {
Slog.i(mTag, "setAllowInstantService(): " + mode);
enforceCallingPermissionForManagement();
synchronized (mLock) {
mAllowInstantService = mode;
}
}
/**
* Temporarily sets the service implementation.
*
* Typically used by Shell command and/or CTS tests.
*
* @param componentName name of the new component
* @param durationMs how long the change will be valid (the service will be automatically reset
* to the default component after this timeout expires).
* @throws SecurityException if caller is not allowed to manage this service's settings.
* @throws IllegalArgumentException if value of {@code durationMs} is higher than
* {@link #getMaximumTemporaryServiceDurationMs()}.
*/
public final void setTemporaryService(@UserIdInt int userId, @NonNull String componentName,
int durationMs) {
Slog.i(mTag, "setTemporaryService(" + userId + ") to " + componentName + " for "
+ durationMs + "ms");
if (mServiceNameResolver == null) {
return;
}
enforceCallingPermissionForManagement();
Objects.requireNonNull(componentName);
final int maxDurationMs = getMaximumTemporaryServiceDurationMs();
if (durationMs > maxDurationMs) {
throw new IllegalArgumentException(
"Max duration is " + maxDurationMs + " (called with " + durationMs + ")");
}
synchronized (mLock) {
final S oldService = peekServiceForUserLocked(userId);
if (oldService != null) {
oldService.removeSelfFromCache();
}
mServiceNameResolver.setTemporaryService(userId, componentName, durationMs);
}
}
/**
* Temporarily sets the service implementation.
*
* Typically used by Shell command and/or CTS tests.
*
* @param componentNames list of the names of the new component
* @param durationMs how long the change will be valid (the service will be automatically
* reset
* to the default component after this timeout expires).
* @throws SecurityException if caller is not allowed to manage this service's settings.
* @throws IllegalArgumentException if value of {@code durationMs} is higher than
* {@link #getMaximumTemporaryServiceDurationMs()}.
*/
public final void setTemporaryServices(@UserIdInt int userId, @NonNull String[] componentNames,
int durationMs) {
Slog.i(mTag, "setTemporaryService(" + userId + ") to " + Arrays.toString(componentNames)
+ " for " + durationMs + "ms");
if (mServiceNameResolver == null) {
return;
}
enforceCallingPermissionForManagement();
Objects.requireNonNull(componentNames);
final int maxDurationMs = getMaximumTemporaryServiceDurationMs();
if (durationMs > maxDurationMs) {
throw new IllegalArgumentException(
"Max duration is " + maxDurationMs + " (called with " + durationMs + ")");
}
synchronized (mLock) {
final S oldService = peekServiceForUserLocked(userId);
if (oldService != null) {
oldService.removeSelfFromCache();
}
mServiceNameResolver.setTemporaryServices(userId, componentNames, durationMs);
}
}
/**
* Sets whether the default service should be used.
*
* Typically used during CTS tests to make sure only the default service doesn't interfere
* with the test results.
*
* @return whether the enabled state changed.
* @throws SecurityException if caller is not allowed to manage this service's settings.
*/
public final boolean setDefaultServiceEnabled(@UserIdInt int userId, boolean enabled) {
Slog.i(mTag, "setDefaultServiceEnabled() for userId " + userId + ": " + enabled);
enforceCallingPermissionForManagement();
synchronized (mLock) {
if (mServiceNameResolver == null) {
return false;
}
final boolean changed = mServiceNameResolver.setDefaultServiceEnabled(userId, enabled);
if (!changed) {
if (verbose) {
Slog.v(mTag, "setDefaultServiceEnabled(" + userId + "): already " + enabled);
}
return false;
}
final S oldService = peekServiceForUserLocked(userId);
if (oldService != null) {
oldService.removeSelfFromCache();
}
// Must update the service on cache so its initialization code is triggered
updateCachedServiceLocked(userId);
}
return true;
}
/**
* Checks whether the default service should be used.
*
* Typically used during CTS tests to make sure only the default service doesn't interfere
* with the test results.
*
* @throws SecurityException if caller is not allowed to manage this service's settings.
*/
public final boolean isDefaultServiceEnabled(@UserIdInt int userId) {
enforceCallingPermissionForManagement();
if (mServiceNameResolver == null) {
return false;
}
synchronized (mLock) {
return mServiceNameResolver.isDefaultServiceEnabled(userId);
}
}
/**
* Gets the maximum time the service implementation can be changed.
*
* @throws UnsupportedOperationException if subclass doesn't override it.
*/
protected int getMaximumTemporaryServiceDurationMs() {
throw new UnsupportedOperationException("Not implemented by " + getClass());
}
/**
* Resets the temporary service implementation to the default component.
*
* Typically used by Shell command and/or CTS tests.
*
* @throws SecurityException if caller is not allowed to manage this service's settings.
*/
public final void resetTemporaryService(@UserIdInt int userId) {
Slog.i(mTag, "resetTemporaryService(): " + userId);
enforceCallingPermissionForManagement();
synchronized (mLock) {
final S service = getServiceForUserLocked(userId);
if (service != null) {
service.resetTemporaryServiceLocked();
}
}
}
/**
* Asserts that the caller has permissions to manage this service.
*
* Typically called by {@code ShellCommand} implementations.
*
* @throws UnsupportedOperationException if subclass doesn't override it.
* @throws SecurityException if caller is not allowed to manage this service's settings.
*/
protected void enforceCallingPermissionForManagement() {
throw new UnsupportedOperationException("Not implemented by " + getClass());
}
/**
* Creates a new service that will be added to the cache.
*
* @param resolvedUserId the resolved user id for the service.
* @param disabled whether the service is currently disabled (due to {@link UserManager}
* restrictions).
*
* @return a new instance.
*/
@Nullable
protected abstract S newServiceLocked(@UserIdInt int resolvedUserId, boolean disabled);
/**
* Creates a new service list that will be added to the cache.
*
* @param resolvedUserId the resolved user id for the service.
* @param disabled whether the service is currently disabled (due to {@link UserManager}
* restrictions).
* @return a new instance.
*/
@Nullable
@GuardedBy("mLock")
protected List Example:
*
* NOTE: By default doesn't do anything, but can be overridden by subclasses.
*/
@SuppressWarnings("unused")
@GuardedBy("mLock")
protected void onServiceEnabledLocked(@NonNull S service, @UserIdInt int userId) {
}
/**
* Removes a cached service list for a given user.
*
* @return the removed service.
*/
@GuardedBy("mLock")
@NonNull
protected final List By default, it calls {@link #updateCachedServiceLocked(int)}; subclasses must either call
* that same method, or {@code super.onServiceNameChanged()}.
*
* @param userId user handle.
* @param serviceName the new service name.
* @param isTemporary whether the new service is temporary.
*/
protected void onServiceNameChanged(@UserIdInt int userId, @Nullable String serviceName,
boolean isTemporary) {
synchronized (mLock) {
updateCachedServiceListLocked(userId, isDisabledLocked(userId));
}
}
/**
* Called when the service name list has changed (typically when using temporary services).
*
* By default, it calls {@link #updateCachedServiceLocked(int)}; subclasses must either call
* that same method, or {@code super.onServiceNameChanged()}.
*
* @param userId user handle.
* @param serviceNames the new service name list.
* @param isTemporary whether the new service is temporary.
*/
protected void onServiceNameListChanged(@UserIdInt int userId, @Nullable String[] serviceNames,
boolean isTemporary) {
synchronized (mLock) {
updateCachedServiceListLocked(userId, isDisabledLocked(userId));
}
}
/**
* Visits all services in the cache.
*/
@GuardedBy("mLock")
protected void visitServicesLocked(@NonNull Visitor "real" service class.
*
* @hide
*/
// TODO(b/117779333): improve javadoc above instead of using Autofill as an example
public abstract class AbstractMasterSystemService newServiceListLocked(@UserIdInt int resolvedUserId, boolean disabled,
String[] serviceNames) {
throw new UnsupportedOperationException("newServiceListLocked not implemented. ");
}
/**
* Register the service for extra Settings changes (i.e., other than
* {@link android.provider.Settings.Secure#USER_SETUP_COMPLETE} or
* {@link #getServiceSettingsProperty()}, which are automatically handled).
*
*
*
*
* resolver.registerContentObserver(Settings.Global.getUriFor(
* Settings.Global.AUTOFILL_LOGGING_LEVEL), false, observer,
* UserHandle.USER_ALL);
* services = getServiceListForUserLocked(userId);
return services == null || services.size() == 0 ? null : services.get(0);
}
/**
* Gets the service instance list for a user, creating instances if not present in the cache.
*/
@GuardedBy("mLock")
protected List getServiceListForUserLocked(@UserIdInt int userId) {
final int resolvedUserId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), userId, false, false, null, null);
List services = mServicesCacheList.get(resolvedUserId);
if (services == null || services.size() == 0) {
final boolean disabled = isDisabledLocked(userId);
if (mServiceNameResolver != null && mServiceNameResolver.isConfiguredInMultipleMode()) {
services = newServiceListLocked(resolvedUserId, disabled,
mServiceNameResolver.getServiceNameList(userId));
} else {
services = new ArrayList<>();
services.add(newServiceLocked(resolvedUserId, disabled));
}
if (!disabled) {
for (int i = 0; i < services.size(); i++) {
onServiceEnabledLocked(services.get(i), resolvedUserId);
}
}
mServicesCacheList.put(userId, services);
}
return services;
}
/**
* Gets the existing service instance for a user, returning {@code null} if not already
* present in the cache.
*/
@GuardedBy("mLock")
@Nullable
protected S peekServiceForUserLocked(@UserIdInt int userId) {
List serviceList = peekServiceListForUserLocked(userId);
return serviceList == null || serviceList.size() == 0 ? null : serviceList.get(0);
}
/**
* Gets the existing service instance for a user, returning {@code null} if not already
* present in the cache.
*/
@GuardedBy("mLock")
@Nullable
protected List peekServiceListForUserLocked(@UserIdInt int userId) {
final int resolvedUserId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), userId, false, false, null, null);
return mServicesCacheList.get(resolvedUserId);
}
/**
* Updates a cached service for a given user.
*/
@GuardedBy("mLock")
protected void updateCachedServiceLocked(@UserIdInt int userId) {
updateCachedServiceListLocked(userId, isDisabledLocked(userId));
}
/**
* Checks whether the service is disabled (through {@link UserManager} restrictions) for the
* given user.
*/
@GuardedBy("mLock")
protected boolean isDisabledLocked(@UserIdInt int userId) {
return mDisabledByUserRestriction != null && mDisabledByUserRestriction.get(userId);
}
/**
* Updates a cached service for a given user.
*
* @param userId user handle.
* @param disabled whether the user is disabled.
* @return service for the user.
*/
@GuardedBy("mLock")
protected S updateCachedServiceLocked(@UserIdInt int userId, boolean disabled) {
final S service = getServiceForUserLocked(userId);
updateCachedServiceListLocked(userId, disabled);
return service;
}
/**
* Updates a cached service for a given user.
*
* @param userId user handle.
* @param disabled whether the user is disabled.
* @return service for the user.
*/
@GuardedBy("mLock")
protected List updateCachedServiceListLocked(@UserIdInt int userId, boolean disabled) {
if (mServiceNameResolver != null
&& mServiceNameResolver.isConfiguredInMultipleMode()) {
// In multiple mode, we have multiple instances of AbstractPerUserSystemService, per
// user where each instance holds information needed to connect to a backend. An
// update operation in this mode needs to account for addition, deletion, change
// of backends and cannot be executed in the scope of a given
// AbstractPerUserSystemService.
return updateCachedServiceListMultiModeLocked(userId, disabled);
}
// isConfiguredInMultipleMode is false
final List services = getServiceListForUserLocked(userId);
if (services == null) {
return null;
}
for (int i = 0; i < services.size(); i++) {
S service = services.get(i);
if (service != null) {
synchronized (service.mLock) {
service.updateLocked(disabled);
if (!service.isEnabledLocked()) {
removeCachedServiceListLocked(userId);
} else {
onServiceEnabledLocked(services.get(i), userId);
}
}
}
}
return services;
}
@GuardedBy("mLock")
private List updateCachedServiceListMultiModeLocked(int userId, boolean disabled) {
final int resolvedUserId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), userId, false, false, null,
null);
List services = new ArrayList<>();
synchronized (mLock) {
removeCachedServiceListLocked(resolvedUserId);
services = getServiceListForUserLocked(userId);
}
return services;
}
/**
* Gets the Settings property that defines the name of the component name used to bind this
* service to an external service, or {@code null} when the service is not defined by such
* property (for example, if it's a system service defined by framework resources).
*/
@Nullable
protected String getServiceSettingsProperty() {
return null;
}
/**
* Callback called after a new service was added to the cache, or an existing service that was
* previously disabled gets enabled.
*
* removeCachedServiceListLocked(@UserIdInt int userId) {
final List services = peekServiceListForUserLocked(userId);
if (services != null) {
mServicesCacheList.delete(userId);
for (int i = 0; i < services.size(); i++) {
onServiceRemoved(services.get(i), userId);
}
}
return services;
}
/**
* Called before the package that provides the service for the given user is being updated.
*/
@GuardedBy("mLock")
protected void onServicePackageUpdatingLocked(@UserIdInt int userId) {
if (verbose) Slog.v(mTag, "onServicePackageUpdatingLocked(" + userId + ")");
}
/**
* Called after the package that provides the service for the given user is being updated.
*/
@GuardedBy("mLock")
protected void onServicePackageUpdatedLocked(@UserIdInt int userId) {
if (verbose) Slog.v(mTag, "onServicePackageUpdated(" + userId + ")");
}
/**
* Called after the package data that provides the service for the given user is cleared.
*/
@GuardedBy("mLock")
protected void onServicePackageDataClearedLocked(@UserIdInt int userId) {
if (verbose) Slog.v(mTag, "onServicePackageDataCleared(" + userId + ")");
}
/**
* Called after the package that provides the service for the given user is restarted.
*/
@GuardedBy("mLock")
protected void onServicePackageRestartedLocked(@UserIdInt int userId) {
if (verbose) Slog.v(mTag, "onServicePackageRestarted(" + userId + ")");
}
/**
* Called after the service is removed from the cache.
*/
@SuppressWarnings("unused")
protected void onServiceRemoved(@NonNull S service, @UserIdInt int userId) {
}
/**
* Called when the service name changed (typically when using temporary services).
*
* visitor) {
final int size = mServicesCacheList.size();
for (int i = 0; i < size; i++) {
List services = mServicesCacheList.valueAt(i);
for (int j = 0; j < services.size(); j++) {
visitor.visit(services.get(j));
}
}
}
/**
* Clear the cache by removing all services.
*/
@GuardedBy("mLock")
protected void clearCacheLocked() {
mServicesCacheList.clear();
}
/**
* Gets a cached reference to {@link UserManagerInternal}.
*/
@NonNull
protected UserManagerInternal getUserManagerInternal() {
if (mUm == null) {
if (verbose) Slog.v(mTag, "lazy-loading UserManagerInternal");
mUm = LocalServices.getService(UserManagerInternal.class);
}
return mUm;
}
/**
* Gets a list of all supported users (i.e., those that pass the
* {@link #isUserSupported(TargetUser)}check).
*/
@NonNull
protected List services = mServicesCacheList.valueAt(i);
for (int j = 0; j < services.size(); j++) {
S service = services.get(j);
synchronized (service.mLock) {
service.dumpLocked(prefix2, pw);
}
}
pw.println();
}
}
} finally {
debug = realDebug;
verbose = realVerbose;
}
}
private class MyPackageMonitor extends PackageMonitor {
MyPackageMonitor(boolean supportsPackageRestartQuery) {
super(supportsPackageRestartQuery);
}
public void startTrackingPackageChanges(Looper looper) {
// package changes
this.register(getContext(), looper, UserHandle.ALL, true);
}
@Override
public void onPackageUpdateStarted(@NonNull String packageName, int uid) {
if (verbose) Slog.v(mTag, "onPackageUpdateStarted(): " + packageName);
synchronized (mLock) {
final String activePackageName = getActiveServicePackageNameLocked();
if (!packageName.equals(activePackageName)) return;
final int userId = getChangingUserId();
if (mUpdatingPackageNames == null) {
mUpdatingPackageNames = new SparseArray visited class.
*/
public interface Visitor {
/**
* Visits a service.
*
* @param service the service to be visited.
*/
void visit(@NonNull S service);
}
private final class SettingsObserver extends ContentObserver {
SettingsObserver(Handler handler) {
super(handler);
ContentResolver resolver = getContext().getContentResolver();
final String serviceProperty = getServiceSettingsProperty();
if (serviceProperty != null) {
resolver.registerContentObserver(Settings.Secure.getUriFor(
serviceProperty), false, this, UserHandle.USER_ALL);
}
resolver.registerContentObserver(Settings.Secure.getUriFor(
Settings.Secure.USER_SETUP_COMPLETE), false, this, UserHandle.USER_ALL);
registerForExtraSettingsChanges(resolver, this);
}
@Override
public void onChange(boolean selfChange, Uri uri, @UserIdInt int userId) {
if (verbose) Slog.v(mTag, "onChange(): uri=" + uri + ", userId=" + userId);
final String property = uri.getLastPathSegment();
if (property == null) {
return;
}
if (property.equals(getServiceSettingsProperty())
|| property.equals(Settings.Secure.USER_SETUP_COMPLETE)) {
synchronized (mLock) {
updateCachedServiceLocked(userId);
}
} else {
onSettingsChanged(userId, property);
}
}
}
}