server/vr/EnabledComponentsObserver.java

/**
 * 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();
        }
    }

}