/**
* Copyright (C) 2016 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.vr;
import android.annotation.NonNull;
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.ContentResolver;
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.os.Handler;
import android.os.Looper;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.ArraySet;
import android.util.Slog;
import android.util.SparseArray;
import com.android.internal.content.PackageMonitor;
import com.android.server.vr.SettingsObserver.SettingChangeListener;
import java.util.Collection;
import java.util.List;
import java.util.Set;
/**
* Detects changes in packages, settings, and current users that may affect whether components
* implementing a given service can be run.
*
* @hide
*/
public class EnabledComponentsObserver implements SettingChangeListener {
private static final String TAG = EnabledComponentsObserver.class.getSimpleName();
private static final String ENABLED_SERVICES_SEPARATOR = ":";
public static final int NO_ERROR = 0;
public static final int DISABLED = -1;
public static final int NOT_INSTALLED = -2;
private final Object mLock;
private final Context mContext;
private final String mSettingName;
private final String mServiceName;
private final String mServicePermission;
private final SparseArray<ArraySet<ComponentName>> mInstalledSet = new SparseArray<>();
private final SparseArray<ArraySet<ComponentName>> mEnabledSet = new SparseArray<>();
private final Set<EnabledComponentChangeListener> mEnabledComponentListeners = new ArraySet<>();
/**
* Implement this to receive callbacks when relevant changes to the allowed components occur.
*/
public interface EnabledComponentChangeListener {
/**
* Called when a change in the allowed components occurs.
*/
void onEnabledComponentChanged();
}
private EnabledComponentsObserver(@NonNull Context context, @NonNull String settingName,
@NonNull String servicePermission, @NonNull String serviceName, @NonNull Object lock,
@NonNull Collection<EnabledComponentChangeListener> listeners) {
mLock = lock;
mContext = context;
mSettingName = settingName;
mServiceName = serviceName;
mServicePermission = servicePermission;
mEnabledComponentListeners.addAll(listeners);
}
/**
* Create a EnabledComponentObserver instance.
*
* @param context the context to query for changes.
* @param handler a handler to receive lifecycle events from system services on.
* @param settingName the name of a setting to monitor for a list of enabled components.
* @param looper a {@link Looper} to use for receiving package callbacks.
* @param servicePermission the permission required by the components to be bound.
* @param serviceName the intent action implemented by the tracked components.
* @param lock a lock object used to guard instance state in all callbacks and method calls.
* @return an EnableComponentObserver instance.
*/
public static EnabledComponentsObserver build(@NonNull Context context,
@NonNull Handler handler, @NonNull String settingName, @NonNull Looper looper,
@NonNull String servicePermission, @NonNull String serviceName,
@NonNull final Object lock,
@NonNull Collection<EnabledComponentChangeListener> listeners) {
SettingsObserver s = SettingsObserver.build(context, handler, settingName);
final EnabledComponentsObserver o = new EnabledComponentsObserver(context, settingName,
servicePermission, serviceName, lock, listeners);
PackageMonitor packageMonitor = new PackageMonitor() {
@Override
public void onSomePackagesChanged() {
o.onPackagesChanged();
}
@Override
public void onPackageDisappeared(String packageName, int reason) {
o.onPackagesChanged();
}
@Override
public void onPackageModified(String packageName) {
o.onPackagesChanged();
}
@Override
public boolean onHandleForceStop(Intent intent, String[] packages, int uid,
boolean doit) {
o.onPackagesChanged();
return super.onHandleForceStop(intent, packages, uid, doit);
}
};
packageMonitor.register(context, looper, UserHandle.ALL, true);
s.addListener(o);
return o;
}
public void onPackagesChanged() {
rebuildAll();
}
@Override
public void onSettingChanged() {
rebuildAll();
}
@Override
public void onSettingRestored(String prevValue, String newValue, int userId) {
rebuildAll();
}
public void onUsersChanged() {
rebuildAll();
}
/**
* Rebuild the sets of allowed components for each current user profile.
*/
public void rebuildAll() {
synchronized (mLock) {
mInstalledSet.clear();
mEnabledSet.clear();
final int[] userIds = getCurrentProfileIds();
for (int i : userIds) {
ArraySet<ComponentName> implementingPackages = loadComponentNamesForUser(i);
ArraySet<ComponentName> packagesFromSettings =
loadComponentNamesFromSetting(mSettingName, i);
packagesFromSettings.retainAll(implementingPackages);
mInstalledSet.put(i, implementingPackages);
mEnabledSet.put(i, packagesFromSettings);
}
}
sendSettingChanged();
}
/**
* Check whether a given component is present and enabled for the given user.
*
* @param component the component to check.
* @param userId the user ID for the component to check.
* @return {@code true} if present and enabled.
*/
public int isValid(ComponentName component, int userId) {
synchronized (mLock) {
ArraySet<ComponentName> installedComponents = mInstalledSet.get(userId);
if (installedComponents == null || !installedComponents.contains(component)) {
return NOT_INSTALLED;
}
ArraySet<ComponentName> validComponents = mEnabledSet.get(userId);
if (validComponents == null || !validComponents.contains(component)) {
return DISABLED;
}
return NO_ERROR;
}
}
/**
* Return all VrListenerService components installed for this user.
*
* @param userId ID of the user to check.
* @return a set of {@link ComponentName}s.
*/
public ArraySet<ComponentName> getInstalled(int userId) {
synchronized (mLock) {
ArraySet<ComponentName> ret = mInstalledSet.get(userId);
if (ret == null) {
return new ArraySet<ComponentName>();
}
return ret;
}
}
/**
* Return all VrListenerService components enabled for this user.
*
* @param userId ID of the user to check.
* @return a set of {@link ComponentName}s.
*/
public ArraySet<ComponentName> getEnabled(int userId) {
synchronized (mLock) {
ArraySet<ComponentName> ret = mEnabledSet.get(userId);
if (ret == null) {
return new ArraySet<ComponentName>();
}
return ret;
}
}
private int[] getCurrentProfileIds() {
UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
if (userManager == null) {
return null;
}
return userManager.getEnabledProfileIds(ActivityManager.getCurrentUser());
}
public static ArraySet<ComponentName> loadComponentNames(PackageManager pm, int userId,
String serviceName, String permissionName) {
ArraySet<ComponentName> installed = new ArraySet<>();
Intent queryIntent = new Intent(serviceName);
List<ResolveInfo> installedServices = pm.queryIntentServicesAsUser(
queryIntent,
PackageManager.GET_SERVICES | PackageManager.GET_META_DATA |
PackageManager.MATCH_DIRECT_BOOT_AWARE |
PackageManager.MATCH_DIRECT_BOOT_UNAWARE,
userId);
if (installedServices != null) {
for (int i = 0, count = installedServices.size(); i < count; i++) {
ResolveInfo resolveInfo = installedServices.get(i);
ServiceInfo info = resolveInfo.serviceInfo;
ComponentName component = new ComponentName(info.packageName, info.name);
if (!permissionName.equals(info.permission)) {
Slog.w(TAG, "Skipping service " + info.packageName + "/" + info.name
+ ": it does not require the permission "
+ permissionName);
continue;
}
installed.add(component);
}
}
return installed;
}
private ArraySet<ComponentName> loadComponentNamesForUser(int userId) {
return loadComponentNames(mContext.getPackageManager(), userId, mServiceName,
mServicePermission);
}
private ArraySet<ComponentName> loadComponentNamesFromSetting(String settingName,
int userId) {
final ContentResolver cr = mContext.getContentResolver();
String settingValue = Settings.Secure.getStringForUser(
cr,
settingName,
userId);
if (TextUtils.isEmpty(settingValue))
return new ArraySet<>();
String[] restored = settingValue.split(ENABLED_SERVICES_SEPARATOR);
ArraySet<ComponentName> result = new ArraySet<>(restored.length);
for (int i = 0; i < restored.length; i++) {
ComponentName value = ComponentName.unflattenFromString(restored[i]);
if (null != value) {
result.add(value);
}
}
return result;
}
private void sendSettingChanged() {
for (EnabledComponentChangeListener l : mEnabledComponentListeners) {
l.onEnabledComponentChanged();
}
}
}