Split NotificationUserManager out of StatusBar. (09322286) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/SystemUIFactory.java

+8 −2

Original line number	Diff line number	Diff line
		@@ -27,6 +27,8 @@ import com.android.keyguard.ViewMediatorCallback;
		import com.android.systemui.Dependency.DependencyProvider;
		import com.android.systemui.keyguard.DismissCallbackRegistry;
		import com.android.systemui.statusbar.KeyguardIndicationController;
		import com.android.systemui.statusbar.NotificationGutsManager;
		import com.android.systemui.statusbar.NotificationLockscreenUserManager;
		import com.android.systemui.statusbar.ScrimView;
		import com.android.systemui.statusbar.phone.DozeParameters;
		import com.android.systemui.statusbar.phone.KeyguardBouncer;
		@@ -39,7 +41,6 @@ import com.android.systemui.qs.QSTileHost;
		import com.android.systemui.statusbar.phone.ScrimController;
		import com.android.systemui.statusbar.phone.StatusBarIconController;
		import com.android.systemui.statusbar.phone.StatusBarKeyguardViewManager;
		import com.android.systemui.volume.VolumeDialogControllerImpl;

		import java.util.function.Consumer;

		@@ -113,5 +114,10 @@ public class SystemUIFactory {
		}

		public void injectDependencies(ArrayMap<Object, DependencyProvider> providers,
		Context context) { }
		Context context) {
		providers.put(NotificationLockscreenUserManager.class,
		() -> new NotificationLockscreenUserManager(context));
		providers.put(NotificationGutsManager.class, () -> new NotificationGutsManager(
		Dependency.get(NotificationLockscreenUserManager.class), context));
		}
		}

packages/SystemUI/src/com/android/systemui/statusbar/NotificationGutsManager.java

+25 −18

Original line number	Diff line number	Diff line
		@@ -37,7 +37,6 @@ import android.view.accessibility.AccessibilityManager;

		import com.android.internal.logging.MetricsLogger;
		import com.android.internal.logging.nano.MetricsProto;
		import com.android.internal.statusbar.IStatusBarService;
		import com.android.systemui.Dependency;
		import com.android.systemui.Dumpable;
		import com.android.systemui.Interpolators;
		@@ -66,30 +65,27 @@ public class NotificationGutsManager implements Dumpable {

		private final MetricsLogger mMetricsLogger = Dependency.get(MetricsLogger.class);
		private final Set<String> mNonBlockablePkgs;
		private final NotificationPresenter mPresenter;
		// TODO: Create NotificationListContainer interface and use it instead of
		// NotificationStackScrollLayout here
		private final NotificationStackScrollLayout mStackScroller;
		private final Context mContext;
		private final AccessibilityManager mAccessibilityManager;
		private final NotificationLockscreenUserManager mLockscreenUserManager;

		// which notification is currently being longpress-examined by the user
		private NotificationGuts mNotificationGutsExposed;
		private NotificationMenuRowPlugin.MenuItem mGutsMenuItem;
		private final NotificationInfo.CheckSaveListener mCheckSaveListener;
		private final OnSettingsClickListener mOnSettingsClickListener;
		private NotificationPresenter mPresenter;

		// TODO: Create NotificationListContainer interface and use it instead of
		// NotificationStackScrollLayout here
		private NotificationStackScrollLayout mStackScroller;
		private NotificationInfo.CheckSaveListener mCheckSaveListener;
		private OnSettingsClickListener mOnSettingsClickListener;
		private String mKeyToRemoveOnGutsClosed;

		public NotificationGutsManager(
		NotificationPresenter presenter,
		NotificationStackScrollLayout stackScroller,
		NotificationInfo.CheckSaveListener checkSaveListener,
		Context context,
		OnSettingsClickListener onSettingsClickListener) {
		mPresenter = presenter;
		mStackScroller = stackScroller;
		mCheckSaveListener = checkSaveListener;
		NotificationLockscreenUserManager lockscreenUserManager,
		Context context) {
		mLockscreenUserManager = lockscreenUserManager;
		mContext = context;
		mOnSettingsClickListener = onSettingsClickListener;
		Resources res = context.getResources();

		mNonBlockablePkgs = new HashSet<>();
		@@ -100,6 +96,16 @@ public class NotificationGutsManager implements Dumpable {
		mContext.getSystemService(Context.ACCESSIBILITY_SERVICE);
		}

		public void setUp(NotificationPresenter presenter,
		NotificationStackScrollLayout stackScroller,
		NotificationInfo.CheckSaveListener checkSaveListener,
		OnSettingsClickListener onSettingsClickListener) {
		mPresenter = presenter;
		mStackScroller = stackScroller;
		mCheckSaveListener = checkSaveListener;
		mOnSettingsClickListener = onSettingsClickListener;
		}

		public String getKeyToRemoveOnGutsClosed() {
		return mKeyToRemoveOnGutsClosed;
		}
		@@ -189,7 +195,7 @@ public class NotificationGutsManager implements Dumpable {
		// system user.
		NotificationInfo.OnSettingsClickListener onSettingsClick = null;
		if (!userHandle.equals(UserHandle.ALL)
		\|\| mPresenter.getCurrentUserId() == UserHandle.USER_SYSTEM) {
		\|\| mLockscreenUserManager.getCurrentUserId() == UserHandle.USER_SYSTEM) {
		onSettingsClick = (View v, NotificationChannel channel, int appUid) -> {
		mMetricsLogger.action(MetricsProto.MetricsEvent.ACTION_NOTE_INFO);
		guts.resetFalsingCheck();
		@@ -354,6 +360,7 @@ public class NotificationGutsManager implements Dumpable {

		@Override
		public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
		pw.println("NotificationGutsManager state:");
		pw.print(" mKeyToRemoveOnGutsClosed: ");
		pw.println(mKeyToRemoveOnGutsClosed);
		}

packages/SystemUI/src/com/android/systemui/statusbar/NotificationLockscreenUserManager.java

0 → 100644

+455 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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.systemui.statusbar;

		import android.app.ActivityManager;
		import android.app.Notification;
		import android.app.admin.DevicePolicyManager;
		import android.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.content.IntentSender;
		import android.content.pm.UserInfo;
		import android.database.ContentObserver;
		import android.os.RemoteException;
		import android.os.ServiceManager;
		import android.os.UserHandle;
		import android.os.UserManager;
		import android.provider.Settings;
		import android.service.notification.StatusBarNotification;
		import android.util.Log;
		import android.util.SparseArray;
		import android.util.SparseBooleanArray;
		import android.widget.TextView;
		import android.widget.Toast;

		import com.android.internal.statusbar.IStatusBarService;
		import com.android.systemui.Dependency;
		import com.android.systemui.Dumpable;
		import com.android.systemui.OverviewProxyService;
		import com.android.systemui.R;
		import com.android.systemui.statusbar.policy.DeviceProvisionedController;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.util.List;

		/**
		* Handles keeping track of the current user, profiles, and various things related to hiding
		* contents, redacting notifications, and the lockscreen.
		*/
		public class NotificationLockscreenUserManager implements Dumpable {
		private static final String TAG = "LockscreenUserManager";
		private static final boolean ENABLE_LOCK_SCREEN_ALLOW_REMOTE_INPUT = false;
		public static final String PERMISSION_SELF = "com.android.systemui.permission.SELF";
		public static final String NOTIFICATION_UNLOCKED_BY_WORK_CHALLENGE_ACTION
		= "com.android.systemui.statusbar.work_challenge_unlocked_notification_action";

		private final DevicePolicyManager mDevicePolicyManager;
		private final SparseBooleanArray mLockscreenPublicMode = new SparseBooleanArray();
		private final SparseBooleanArray mUsersAllowingPrivateNotifications = new SparseBooleanArray();
		private final SparseBooleanArray mUsersAllowingNotifications = new SparseBooleanArray();
		private final DeviceProvisionedController mDeviceProvisionedController =
		Dependency.get(DeviceProvisionedController.class);
		private final UserManager mUserManager;
		private final IStatusBarService mBarService;

		private boolean mShowLockscreenNotifications;
		private boolean mAllowLockscreenRemoteInput;

		protected final BroadcastReceiver mAllUsersReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
		final String action = intent.getAction();
		final int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);

		if (DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED.equals(action) &&
		isCurrentProfile(getSendingUserId())) {
		mUsersAllowingPrivateNotifications.clear();
		updateLockscreenNotificationSetting();
		mPresenter.updateNotifications();
		} else if (Intent.ACTION_DEVICE_LOCKED_CHANGED.equals(action)) {
		if (userId != mCurrentUserId && isCurrentProfile(userId)) {
		mPresenter.onWorkChallengeChanged();
		}
		}
		}
		};

		protected final BroadcastReceiver mBaseBroadcastReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
		String action = intent.getAction();
		if (Intent.ACTION_USER_SWITCHED.equals(action)) {
		mCurrentUserId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, -1);
		updateCurrentProfilesCache();
		Log.v(TAG, "userId " + mCurrentUserId + " is in the house");

		updateLockscreenNotificationSetting();

		mPresenter.onUserSwitched(mCurrentUserId);
		} else if (Intent.ACTION_USER_ADDED.equals(action)) {
		updateCurrentProfilesCache();
		} else if (Intent.ACTION_USER_UNLOCKED.equals(action)) {
		// Start the overview connection to the launcher service
		Dependency.get(OverviewProxyService.class).startConnectionToCurrentUser();
		} else if (Intent.ACTION_USER_PRESENT.equals(action)) {
		List<ActivityManager.RecentTaskInfo> recentTask = null;
		try {
		recentTask = ActivityManager.getService().getRecentTasks(1,
		ActivityManager.RECENT_WITH_EXCLUDED,
		mCurrentUserId).getList();
		} catch (RemoteException e) {
		// Abandon hope activity manager not running.
		}
		if (recentTask != null && recentTask.size() > 0) {
		UserInfo user = mUserManager.getUserInfo(recentTask.get(0).userId);
		if (user != null && user.isManagedProfile()) {
		Toast toast = Toast.makeText(mContext,
		R.string.managed_profile_foreground_toast,
		Toast.LENGTH_SHORT);
		TextView text = toast.getView().findViewById(android.R.id.message);
		text.setCompoundDrawablesRelativeWithIntrinsicBounds(
		R.drawable.stat_sys_managed_profile_status, 0, 0, 0);
		int paddingPx = mContext.getResources().getDimensionPixelSize(
		R.dimen.managed_profile_toast_padding);
		text.setCompoundDrawablePadding(paddingPx);
		toast.show();
		}
		}
		} else if (NOTIFICATION_UNLOCKED_BY_WORK_CHALLENGE_ACTION.equals(action)) {
		final IntentSender intentSender = intent.getParcelableExtra(Intent.EXTRA_INTENT);
		final String notificationKey = intent.getStringExtra(Intent.EXTRA_INDEX);
		if (intentSender != null) {
		try {
		mContext.startIntentSender(intentSender, null, 0, 0, 0);
		} catch (IntentSender.SendIntentException e) {
		/* ignore */
		}
		}
		if (notificationKey != null) {
		try {
		mBarService.onNotificationClick(notificationKey);
		} catch (RemoteException e) {
		/* ignore */
		}
		}
		}
		}
		};

		protected final Context mContext;
		protected final SparseArray<UserInfo> mCurrentProfiles = new SparseArray<>();

		protected int mCurrentUserId = 0;
		protected NotificationPresenter mPresenter;
		protected ContentObserver mLockscreenSettingsObserver;
		protected ContentObserver mSettingsObserver;

		public NotificationLockscreenUserManager(Context context) {
		mContext = context;
		mDevicePolicyManager = (DevicePolicyManager) mContext.getSystemService(
		Context.DEVICE_POLICY_SERVICE);
		mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
		mCurrentUserId = ActivityManager.getCurrentUser();
		mBarService = IStatusBarService.Stub.asInterface(
		ServiceManager.getService(Context.STATUS_BAR_SERVICE));
		}

		public void setUpWithPresenter(NotificationPresenter presenter) {
		mPresenter = presenter;

		mLockscreenSettingsObserver = new ContentObserver(mPresenter.getHandler()) {
		@Override
		public void onChange(boolean selfChange) {
		// We don't know which user changed LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS or
		// LOCK_SCREEN_SHOW_NOTIFICATIONS, so we just dump our cache ...
		mUsersAllowingPrivateNotifications.clear();
		mUsersAllowingNotifications.clear();
		// ... and refresh all the notifications
		updateLockscreenNotificationSetting();
		mPresenter.updateNotifications();
		}
		};

		mSettingsObserver = new ContentObserver(mPresenter.getHandler()) {
		@Override
		public void onChange(boolean selfChange) {
		updateLockscreenNotificationSetting();
		if (mDeviceProvisionedController.isDeviceProvisioned()) {
		mPresenter.updateNotifications();
		}
		}
		};

		mContext.getContentResolver().registerContentObserver(
		Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS), false,
		mLockscreenSettingsObserver,
		UserHandle.USER_ALL);

		mContext.getContentResolver().registerContentObserver(
		Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS),
		true,
		mLockscreenSettingsObserver,
		UserHandle.USER_ALL);

		mContext.getContentResolver().registerContentObserver(
		Settings.Global.getUriFor(Settings.Global.ZEN_MODE), false,
		mSettingsObserver);

		if (ENABLE_LOCK_SCREEN_ALLOW_REMOTE_INPUT) {
		mContext.getContentResolver().registerContentObserver(
		Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_ALLOW_REMOTE_INPUT),
		false,
		mSettingsObserver,
		UserHandle.USER_ALL);
		}

		IntentFilter allUsersFilter = new IntentFilter();
		allUsersFilter.addAction(
		DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);
		allUsersFilter.addAction(Intent.ACTION_DEVICE_LOCKED_CHANGED);
		mContext.registerReceiverAsUser(mAllUsersReceiver, UserHandle.ALL, allUsersFilter,
		null, null);

		IntentFilter filter = new IntentFilter();
		filter.addAction(Intent.ACTION_USER_SWITCHED);
		filter.addAction(Intent.ACTION_USER_ADDED);
		filter.addAction(Intent.ACTION_USER_PRESENT);
		filter.addAction(Intent.ACTION_USER_UNLOCKED);
		mContext.registerReceiver(mBaseBroadcastReceiver, filter);

		IntentFilter internalFilter = new IntentFilter();
		internalFilter.addAction(NOTIFICATION_UNLOCKED_BY_WORK_CHALLENGE_ACTION);
		mContext.registerReceiver(mBaseBroadcastReceiver, internalFilter, PERMISSION_SELF, null);

		updateCurrentProfilesCache();

		mSettingsObserver.onChange(false); // set up
		}

		public boolean shouldShowLockscreenNotifications() {
		return mShowLockscreenNotifications;
		}

		public boolean shouldAllowLockscreenRemoteInput() {
		return mAllowLockscreenRemoteInput;
		}

		public boolean isCurrentProfile(int userId) {
		synchronized (mCurrentProfiles) {
		return userId == UserHandle.USER_ALL \|\| mCurrentProfiles.get(userId) != null;
		}
		}

		/**
		* Returns true if we're on a secure lockscreen and the user wants to hide notification data.
		* If so, notifications should be hidden.
		*/
		public boolean shouldHideNotifications(int userId) {
		return isLockscreenPublicMode(userId) && !userAllowsNotificationsInPublic(userId)
		\|\| (userId != mCurrentUserId && shouldHideNotifications(mCurrentUserId));
		}

		/**
		* Returns true if we're on a secure lockscreen and the user wants to hide notifications via
		* package-specific override.
		*/
		public boolean shouldHideNotifications(String key) {
		return isLockscreenPublicMode(mCurrentUserId)
		&& mPresenter.getNotificationData().getVisibilityOverride(key) ==
		Notification.VISIBILITY_SECRET;
		}

		public boolean shouldShowOnKeyguard(StatusBarNotification sbn) {
		return mShowLockscreenNotifications
		&& !mPresenter.getNotificationData().isAmbient(sbn.getKey());
		}

		private void setShowLockscreenNotifications(boolean show) {
		mShowLockscreenNotifications = show;
		}

		private void setLockscreenAllowRemoteInput(boolean allowLockscreenRemoteInput) {
		mAllowLockscreenRemoteInput = allowLockscreenRemoteInput;
		}

		protected void updateLockscreenNotificationSetting() {
		final boolean show = Settings.Secure.getIntForUser(mContext.getContentResolver(),
		Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS,
		1,
		mCurrentUserId) != 0;
		final int dpmFlags = mDevicePolicyManager.getKeyguardDisabledFeatures(
		null /* admin */, mCurrentUserId);
		final boolean allowedByDpm = (dpmFlags
		& DevicePolicyManager.KEYGUARD_DISABLE_SECURE_NOTIFICATIONS) == 0;

		setShowLockscreenNotifications(show && allowedByDpm);

		if (ENABLE_LOCK_SCREEN_ALLOW_REMOTE_INPUT) {
		final boolean remoteInput = Settings.Secure.getIntForUser(mContext.getContentResolver(),
		Settings.Secure.LOCK_SCREEN_ALLOW_REMOTE_INPUT,
		0,
		mCurrentUserId) != 0;
		final boolean remoteInputDpm =
		(dpmFlags & DevicePolicyManager.KEYGUARD_DISABLE_REMOTE_INPUT) == 0;

		setLockscreenAllowRemoteInput(remoteInput && remoteInputDpm);
		} else {
		setLockscreenAllowRemoteInput(false);
		}
		}

		/**
		* Has the given user chosen to allow their private (full) notifications to be shown even
		* when the lockscreen is in "public" (secure & locked) mode?
		*/
		public boolean userAllowsPrivateNotificationsInPublic(int userHandle) {
		if (userHandle == UserHandle.USER_ALL) {
		return true;
		}

		if (mUsersAllowingPrivateNotifications.indexOfKey(userHandle) < 0) {
		final boolean allowedByUser = 0 != Settings.Secure.getIntForUser(
		mContext.getContentResolver(),
		Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 0, userHandle);
		final boolean allowedByDpm = adminAllowsUnredactedNotifications(userHandle);
		final boolean allowed = allowedByUser && allowedByDpm;
		mUsersAllowingPrivateNotifications.append(userHandle, allowed);
		return allowed;
		}

		return mUsersAllowingPrivateNotifications.get(userHandle);
		}

		private boolean adminAllowsUnredactedNotifications(int userHandle) {
		if (userHandle == UserHandle.USER_ALL) {
		return true;
		}
		final int dpmFlags = mDevicePolicyManager.getKeyguardDisabledFeatures(null /* admin */,
		userHandle);
		return (dpmFlags & DevicePolicyManager.KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS) == 0;
		}

		/**
		* Save the current "public" (locked and secure) state of the lockscreen.
		*/
		public void setLockscreenPublicMode(boolean publicMode, int userId) {
		mLockscreenPublicMode.put(userId, publicMode);
		}

		public boolean isLockscreenPublicMode(int userId) {
		if (userId == UserHandle.USER_ALL) {
		return mLockscreenPublicMode.get(mCurrentUserId, false);
		}
		return mLockscreenPublicMode.get(userId, false);
		}

		/**
		* Has the given user chosen to allow notifications to be shown even when the lockscreen is in
		* "public" (secure & locked) mode?
		*/
		private boolean userAllowsNotificationsInPublic(int userHandle) {
		if (userHandle == UserHandle.USER_ALL) {
		return true;
		}

		if (mUsersAllowingNotifications.indexOfKey(userHandle) < 0) {
		final boolean allowed = 0 != Settings.Secure.getIntForUser(
		mContext.getContentResolver(),
		Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, 0, userHandle);
		mUsersAllowingNotifications.append(userHandle, allowed);
		return allowed;
		}

		return mUsersAllowingNotifications.get(userHandle);
		}

		/** @return true if the entry needs redaction when on the lockscreen. */
		public boolean needsRedaction(NotificationData.Entry ent) {
		int userId = ent.notification.getUserId();

		boolean currentUserWantsRedaction = !userAllowsPrivateNotificationsInPublic(mCurrentUserId);
		boolean notiUserWantsRedaction = !userAllowsPrivateNotificationsInPublic(userId);
		boolean redactedLockscreen = currentUserWantsRedaction \|\| notiUserWantsRedaction;

		boolean notificationRequestsRedaction =
		ent.notification.getNotification().visibility == Notification.VISIBILITY_PRIVATE;
		boolean userForcesRedaction = packageHasVisibilityOverride(ent.notification.getKey());

		return userForcesRedaction \|\| notificationRequestsRedaction && redactedLockscreen;
		}

		private boolean packageHasVisibilityOverride(String key) {
		return mPresenter.getNotificationData().getVisibilityOverride(key) ==
		Notification.VISIBILITY_PRIVATE;
		}


		private void updateCurrentProfilesCache() {
		synchronized (mCurrentProfiles) {
		mCurrentProfiles.clear();
		if (mUserManager != null) {
		for (UserInfo user : mUserManager.getProfiles(mCurrentUserId)) {
		mCurrentProfiles.put(user.id, user);
		}
		}
		}
		}

		public boolean isAnyProfilePublicMode() {
		for (int i = mCurrentProfiles.size() - 1; i >= 0; i--) {
		if (isLockscreenPublicMode(mCurrentProfiles.valueAt(i).id)) {
		return true;
		}
		}
		return false;
		}

		/**
		* Returns the current user id. This can change if the user is switched.
		*/
		public int getCurrentUserId() {
		return mCurrentUserId;
		}

		public SparseArray<UserInfo> getCurrentProfiles() {
		return mCurrentProfiles;
		}

		public void destroy() {
		mContext.unregisterReceiver(mBaseBroadcastReceiver);
		mContext.unregisterReceiver(mAllUsersReceiver);
		}

		@Override
		public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
		pw.println("NotificationLockscreenUserManager state:");
		pw.print(" mCurrentUserId=");
		pw.println(mCurrentUserId);
		pw.print(" mShowLockscreenNotifications=");
		pw.println(mShowLockscreenNotifications);
		pw.print(" mAllowLockscreenRemoteInput=");
		pw.println(mAllowLockscreenRemoteInput);
		pw.print(" mCurrentProfiles=");
		for (int i = mCurrentProfiles.size() - 1; i >= 0; i--) {
		final int userId = mCurrentProfiles.valueAt(i).id;
		pw.print("" + userId + " ");
		}
		pw.println();
		}
		}