android/safetycenter/SafetyCenterBroadcastDispatcher.java

/*
 * Copyright (C) 2022 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.safetycenter;

import static android.Manifest.permission.READ_SAFETY_CENTER_STATUS;
import static android.Manifest.permission.SEND_SAFETY_CENTER_UPDATE;
import static android.content.Intent.FLAG_RECEIVER_FOREGROUND;
import static android.os.Build.VERSION_CODES.TIRAMISU;
import static android.os.PowerExemptionManager.REASON_REFRESH_SAFETY_SOURCES;
import static android.os.PowerExemptionManager.TEMPORARY_ALLOW_LIST_TYPE_FOREGROUND_SERVICE_ALLOWED;
import static android.safetycenter.SafetyCenterManager.ACTION_REFRESH_SAFETY_SOURCES;
import static android.safetycenter.SafetyCenterManager.ACTION_SAFETY_CENTER_ENABLED_CHANGED;
import static android.safetycenter.SafetyCenterManager.EXTRA_REFRESH_SAFETY_SOURCES_BROADCAST_ID;
import static android.safetycenter.SafetyCenterManager.EXTRA_REFRESH_SAFETY_SOURCES_REQUEST_TYPE;
import static android.safetycenter.SafetyCenterManager.EXTRA_REFRESH_SAFETY_SOURCE_IDS;
import static android.safetycenter.SafetyCenterManager.REFRESH_REASON_PAGE_OPEN;
import static android.safetycenter.SafetyCenterManager.REFRESH_REASON_SAFETY_CENTER_ENABLED;

import static java.util.Collections.unmodifiableList;

import android.annotation.Nullable;
import android.annotation.SuppressLint;
import android.annotation.UserIdInt;
import android.app.BroadcastOptions;
import android.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.UserHandle;
import android.safetycenter.SafetyCenterManager;
import android.safetycenter.SafetyCenterManager.RefreshReason;
import android.safetycenter.SafetyCenterManager.RefreshRequestType;
import android.safetycenter.SafetySourceData;
import android.util.ArraySet;
import android.util.Log;
import android.util.SparseArray;

import androidx.annotation.RequiresApi;

import com.android.permission.util.PackageUtils;
import com.android.safetycenter.SafetyCenterConfigReader.Broadcast;
import com.android.safetycenter.data.SafetyCenterDataManager;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;

import javax.annotation.concurrent.NotThreadSafe;

/**
 * A class that dispatches SafetyCenter broadcasts.
 *
 * <p>This class isn't thread safe. Thread safety must be handled by the caller.
 */
@RequiresApi(TIRAMISU)
@NotThreadSafe
final class SafetyCenterBroadcastDispatcher {
    private static final String TAG = "SafetyCenterBroadcastDi";

    private final Context mContext;
    private final SafetyCenterConfigReader mSafetyCenterConfigReader;
    private final SafetyCenterRefreshTracker mSafetyCenterRefreshTracker;
    private final SafetyCenterDataManager mSafetyCenterDataManager;

    SafetyCenterBroadcastDispatcher(
            Context context,
            SafetyCenterConfigReader safetyCenterConfigReader,
            SafetyCenterRefreshTracker safetyCenterRefreshTracker,
            SafetyCenterDataManager safetyCenterDataManager) {
        mContext = context;
        mSafetyCenterConfigReader = safetyCenterConfigReader;
        mSafetyCenterRefreshTracker = safetyCenterRefreshTracker;
        mSafetyCenterDataManager = safetyCenterDataManager;
    }

    /**
     * Triggers a refresh of safety sources by sending them broadcasts with action {@link
     * SafetyCenterManager#ACTION_REFRESH_SAFETY_SOURCES}, and returns the associated broadcast id.
     *
     * <p>Returns {@code null} if no broadcast was sent.
     *
     * @param safetySourceIds list of IDs to specify the safety sources to be refreshed or a {@code
     *     null} value to refresh all safety sources.
     */
    @Nullable
    String sendRefreshSafetySources(
            @RefreshReason int refreshReason,
            UserProfileGroup userProfileGroup,
            @Nullable List<String> safetySourceIds) {
        List<Broadcast> broadcasts = mSafetyCenterConfigReader.getBroadcasts();
        BroadcastOptions broadcastOptions = createBroadcastOptions();

        String broadcastId =
                mSafetyCenterRefreshTracker.reportRefreshInProgress(
                        refreshReason, userProfileGroup);
        boolean hasSentAtLeastOneBroadcast = false;

        for (int i = 0; i < broadcasts.size(); i++) {
            Broadcast broadcast = broadcasts.get(i);

            hasSentAtLeastOneBroadcast |=
                    sendRefreshSafetySourcesBroadcast(
                            broadcast,
                            broadcastOptions,
                            refreshReason,
                            userProfileGroup,
                            broadcastId,
                            safetySourceIds);
        }

        if (!hasSentAtLeastOneBroadcast) {
            mSafetyCenterRefreshTracker.clearRefresh(broadcastId);
            return null;
        }

        return broadcastId;
    }

    private boolean sendRefreshSafetySourcesBroadcast(
            Broadcast broadcast,
            BroadcastOptions broadcastOptions,
            @RefreshReason int refreshReason,
            UserProfileGroup userProfileGroup,
            String broadcastId,
            @Nullable List<String> requiredSourceIds) {
        boolean hasSentAtLeastOneBroadcast = false;
        int requestType = RefreshReasons.toRefreshRequestType(refreshReason);
        String packageName = broadcast.getPackageName();
        Set<String> deniedSourceIds = getRefreshDeniedSourceIds(refreshReason);
        SparseArray<List<String>> userIdsToSourceIds =
                getUserIdsToSourceIds(broadcast, userProfileGroup, refreshReason);

        for (int i = 0; i < userIdsToSourceIds.size(); i++) {
            int userId = userIdsToSourceIds.keyAt(i);
            List<String> sourceIds = userIdsToSourceIds.valueAt(i);

            if (!deniedSourceIds.isEmpty()) {
                sourceIds = new ArrayList<>(sourceIds);
                sourceIds.removeAll(deniedSourceIds);
            }

            if (requiredSourceIds != null) {
                sourceIds = new ArrayList<>(sourceIds);
                sourceIds.retainAll(requiredSourceIds);
            }

            if (sourceIds.isEmpty()) {
                continue;
            }

            Intent intent = createRefreshIntent(requestType, packageName, sourceIds, broadcastId);
            boolean broadcastWasSent =
                    sendBroadcastIfResolves(intent, UserHandle.of(userId), broadcastOptions);
            if (broadcastWasSent) {
                mSafetyCenterRefreshTracker.reportSourceRefreshesInFlight(
                        broadcastId, sourceIds, userId);
            }
            hasSentAtLeastOneBroadcast |= broadcastWasSent;
        }

        return hasSentAtLeastOneBroadcast;
    }

    /**
     * Triggers an {@link SafetyCenterManager#ACTION_SAFETY_CENTER_ENABLED_CHANGED} broadcast for
     * all safety sources.
     *
     * <p>This method also sends an implicit broadcast globally (which requires the {@link
     * android.Manifest.permission#READ_SAFETY_CENTER_STATUS} permission).
     */
    // TODO(b/227310195): Consider adding a boolean extra to the intent instead of having clients
    //  rely on SafetyCenterManager#isSafetyCenterEnabled()?
    void sendEnabledChanged() {
        List<Broadcast> broadcasts = mSafetyCenterConfigReader.getBroadcasts();
        BroadcastOptions broadcastOptions = createBroadcastOptions();
        List<UserProfileGroup> userProfileGroups =
                UserProfileGroup.getAllUserProfileGroups(mContext);

        for (int i = 0; i < broadcasts.size(); i++) {
            Broadcast broadcast = broadcasts.get(i);

            sendEnabledChangedBroadcast(broadcast, broadcastOptions, userProfileGroups);
        }

        Intent implicitIntent = createImplicitEnabledChangedIntent();
        sendBroadcast(implicitIntent, UserHandle.SYSTEM, READ_SAFETY_CENTER_STATUS, null);
    }

    private void sendEnabledChangedBroadcast(
            Broadcast broadcast,
            BroadcastOptions broadcastOptions,
            List<UserProfileGroup> userProfileGroups) {
        Intent intent = createExplicitEnabledChangedIntent(broadcast.getPackageName());
        // The same ENABLED reason is used here for both enable and disable events. It is not sent
        // externally and is only used internally to filter safety sources in the methods of the
        // Broadcast class.
        int refreshReason = REFRESH_REASON_SAFETY_CENTER_ENABLED;

        for (int i = 0; i < userProfileGroups.size(); i++) {
            UserProfileGroup userProfileGroup = userProfileGroups.get(i);
            SparseArray<List<String>> userIdsToSourceIds =
                    getUserIdsToSourceIds(broadcast, userProfileGroup, refreshReason);

            for (int j = 0; j < userIdsToSourceIds.size(); j++) {
                int userId = userIdsToSourceIds.keyAt(j);

                sendBroadcastIfResolves(intent, UserHandle.of(userId), broadcastOptions);
            }
        }
    }

    private boolean sendBroadcastIfResolves(
            Intent intent, UserHandle userHandle, @Nullable BroadcastOptions broadcastOptions) {
        if (!doesBroadcastResolve(intent, userHandle)) {
            Log.w(
                    TAG,
                    "No receiver for intent targeting "
                            + intent.getPackage()
                            + " and user "
                            + userHandle);
            return false;
        }
        Log.v(
                TAG,
                "Found receiver for intent targeting "
                        + intent.getPackage()
                        + " and user "
                        + userHandle);
        sendBroadcast(intent, userHandle, SEND_SAFETY_CENTER_UPDATE, broadcastOptions);
        return true;
    }

    // TODO(b/193460475): Remove when tooling supports SystemApi to public API.
    @SuppressLint("NewApi")
    private void sendBroadcast(
            Intent intent,
            UserHandle userHandle,
            String permission,
            @Nullable BroadcastOptions broadcastOptions) {
        // This call requires the INTERACT_ACROSS_USERS permission.
        final long callingId = Binder.clearCallingIdentity();
        try {
            mContext.sendBroadcastAsUser(
                    intent,
                    userHandle,
                    permission,
                    broadcastOptions == null ? null : broadcastOptions.toBundle());
        } finally {
            Binder.restoreCallingIdentity(callingId);
        }
    }

    private boolean doesBroadcastResolve(Intent broadcastIntent, UserHandle userHandle) {
        return !PackageUtils.queryUnfilteredBroadcastReceiversAsUser(
                        broadcastIntent, 0, userHandle.getIdentifier(), mContext)
                .isEmpty();
    }

    private static Intent createExplicitEnabledChangedIntent(String packageName) {
        return createImplicitEnabledChangedIntent().setPackage(packageName);
    }

    private static Intent createImplicitEnabledChangedIntent() {
        return createBroadcastIntent(ACTION_SAFETY_CENTER_ENABLED_CHANGED);
    }

    private static Intent createRefreshIntent(
            @RefreshRequestType int requestType,
            String packageName,
            List<String> sourceIdsToRefresh,
            String broadcastId) {
        String[] sourceIdsArray = sourceIdsToRefresh.toArray(new String[0]);
        return createBroadcastIntent(ACTION_REFRESH_SAFETY_SOURCES)
                .putExtra(EXTRA_REFRESH_SAFETY_SOURCES_REQUEST_TYPE, requestType)
                .putExtra(EXTRA_REFRESH_SAFETY_SOURCE_IDS, sourceIdsArray)
                .putExtra(EXTRA_REFRESH_SAFETY_SOURCES_BROADCAST_ID, broadcastId)
                .setPackage(packageName);
    }

    private static Intent createBroadcastIntent(String intentAction) {
        return new Intent(intentAction).setFlags(FLAG_RECEIVER_FOREGROUND);
    }

    // TODO(b/193460475): Remove when tooling supports SystemApi to public API.
    @SuppressLint("NewApi")
    private static BroadcastOptions createBroadcastOptions() {
        BroadcastOptions broadcastOptions = BroadcastOptions.makeBasic();
        Duration allowListDuration = SafetyCenterFlags.getFgsAllowlistDuration();
        // This call requires the START_FOREGROUND_SERVICES_FROM_BACKGROUND permission.
        final long callingId = Binder.clearCallingIdentity();
        try {
            broadcastOptions.setTemporaryAppAllowlist(
                    allowListDuration.toMillis(),
                    TEMPORARY_ALLOW_LIST_TYPE_FOREGROUND_SERVICE_ALLOWED,
                    REASON_REFRESH_SAFETY_SOURCES,
                    "Safety Center is requesting data from safety sources");
        } finally {
            Binder.restoreCallingIdentity(callingId);
        }
        return broadcastOptions;
    }

    /** Returns the list of source IDs for which refreshing is denied for the given reason. */
    private static Set<String> getRefreshDeniedSourceIds(@RefreshReason int refreshReason) {
        if (RefreshReasons.isBackgroundRefresh(refreshReason)) {
            return SafetyCenterFlags.getBackgroundRefreshDeniedSourceIds();
        } else {
            return Collections.emptySet();
        }
    }

    /**
     * Returns a flattened mapping from user IDs to lists of source IDs for those users. The map is
     * in the form of a {@link SparseArray} where the int keys are user IDs and the values are the
     * lists of source IDs.
     *
     * <p>The set of user IDs (keys) is the profile parent user ID of {@code userProfileGroup} plus
     * the (possibly empty) set of running managed profile user IDs in that group.
     *
     * <p>Every value present is a non-empty list, but the overall result may be empty.
     */
    private SparseArray<List<String>> getUserIdsToSourceIds(
            Broadcast broadcast,
            UserProfileGroup userProfileGroup,
            @RefreshReason int refreshReason) {
        int[] managedProfileIds = userProfileGroup.getManagedRunningProfilesUserIds();
        SparseArray<List<String>> result = new SparseArray<>(managedProfileIds.length + 1);
        List<String> profileParentSources =
                getSourceIdsForRefreshReason(
                        refreshReason,
                        broadcast.getSourceIdsForProfileParent(),
                        broadcast.getSourceIdsForProfileParentOnPageOpen(),
                        userProfileGroup.getProfileParentUserId());

        if (!profileParentSources.isEmpty()) {
            result.put(userProfileGroup.getProfileParentUserId(), profileParentSources);
        }

        for (int i = 0; i < managedProfileIds.length; i++) {
            List<String> managedProfileSources =
                    getSourceIdsForRefreshReason(
                            refreshReason,
                            broadcast.getSourceIdsForManagedProfiles(),
                            broadcast.getSourceIdsForManagedProfilesOnPageOpen(),
                            managedProfileIds[i]);

            if (!managedProfileSources.isEmpty()) {
                result.put(managedProfileIds[i], managedProfileSources);
            }
        }

        return result;
    }

    /**
     * Returns the sources to refresh for the given {@code refreshReason}.
     *
     * <p>For {@link SafetyCenterManager#REFRESH_REASON_PAGE_OPEN}, returns a copy of {@code
     * allSourceIds} filtered to contain only sources that have refreshOnPageOpenAllowed in the XML
     * config, or are in the safety_center_override_refresh_on_page_open_sources flag, or don't have
     * any {@link SafetySourceData} provided.
     */
    private List<String> getSourceIdsForRefreshReason(
            @RefreshReason int refreshReason,
            List<String> allSourceIds,
            List<String> pageOpenSourceIds,
            @UserIdInt int userId) {
        if (refreshReason != REFRESH_REASON_PAGE_OPEN) {
            return allSourceIds;
        }

        List<String> sourceIds = new ArrayList<>();

        ArraySet<String> flagAllowListedSourceIds =
                SafetyCenterFlags.getOverrideRefreshOnPageOpenSourceIds();

        for (int i = 0; i < allSourceIds.size(); i++) {
            String sourceId = allSourceIds.get(i);
            if (pageOpenSourceIds.contains(sourceId)
                    || flagAllowListedSourceIds.contains(sourceId)
                    || mSafetyCenterDataManager.getSafetySourceDataInternal(
                                    SafetySourceKey.of(sourceId, userId))
                            == null) {
                sourceIds.add(sourceId);
            }
        }

        return unmodifiableList(sourceIds);
    }
}