PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topic "lockscreen-notif-settings-page" into main

Browse Source 
* changes:
  Replace the existing notifications on lock screen preferences with new page
  Implement the preference switch for minimalism on ls settings page
  Implement the Hide seen notifications toggle
  Implement the hide silent notifications toggle
  Implement the show sensitive content toggle
  Implement the main switch of notifications on lock screen
  Add the new settings page for lock screen notifs
This commit is contained in:
Yining Liu
2024-12-05 05:49:31 +00:00
committed by Android (Google) Code Review
parent 69a0c61feb 85aa7f7c86
commit 84571f53f9
22 changed files with 1609 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
res/layout/notification_ls_minimalism_selector.xml Normal file
View File

@@ -0,0 +1,121 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ Copyright (C) 2024 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.
-->
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="wrap_content">
<TextView
android:id="@+id/notif_ls_style_desc"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:paddingVertical="@dimen/settingslib_illustration_padding"
android:paddingEnd="48dp"
android:paddingStart="48dp"
android:layout_gravity="center_horizontal"
android:gravity="center"
android:focusable="true"
android:textAppearance="?android:attr/textAppearanceSmall"
android:textColor="?android:attr/textColorSecondary"/>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginBottom="16dp"
android:orientation="horizontal">
<Space
android:layout_width="0dp"
android:layout_height="match_parent"
android:layout_weight="1"/>
<LinearLayout
android:id="@+id/button_compact"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="vertical">
<FrameLayout
android:layout_width="@dimen/contrast_button_total_size"
android:layout_height="@dimen/contrast_button_total_size"
android:background="@drawable/accessibility_contrast_button_background">
<ImageView
android:layout_gravity="center"
android:layout_height="wrap_content"
android:layout_width="wrap_content"
android:contentDescription="@null"
android:src="@drawable/ic_contrast_standard"/>
</FrameLayout>
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="@dimen/contrast_button_text_spacing"
android:gravity="center_horizontal|top"
android:ellipsize="end"
android:singleLine="true"
android:textSize="@dimen/contrast_button_text_size"
android:text="@string/lock_screen_notifs_show_compact"
android:textColor="?androidprv:attr/materialColorOnSurface"/>
</LinearLayout>
<Space
android:layout_width="@dimen/contrast_button_horizontal_spacing"
android:layout_height="match_parent" />
<LinearLayout
android:id="@+id/button_full"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="vertical">
<FrameLayout
android:layout_width="@dimen/contrast_button_total_size"
android:layout_height="@dimen/contrast_button_total_size"
android:background="@drawable/accessibility_contrast_button_background">
<ImageView
android:layout_gravity="center"
android:layout_height="wrap_content"
android:layout_width="wrap_content"
android:contentDescription="@null"
android:src="@drawable/ic_contrast_high"/>
</FrameLayout>
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="@dimen/contrast_button_text_spacing"
android:gravity="center_horizontal|top"
android:ellipsize="end"
android:singleLine="true"
android:textSize="@dimen/contrast_button_text_size"
android:text="@string/lock_screen_notifs_show_full_list"
android:textColor="?androidprv:attr/materialColorOnSurface"/>
</LinearLayout>
<Space
android:layout_width="0dp"
android:layout_height="match_parent"
android:layout_weight="1"/>
</LinearLayout>
</LinearLayout>

24
res/values/strings.xml
View File

@@ -8789,6 +8789,18 @@
<!-- Configure notifications: Summary for option of showing only new notifications on the lock screen. [CHAR LIMIT=100] -->
<string name="unseen_notifs_lock_screen_summary">Automatically remove previously viewed notifications from the lock screen</string>
<!-- Configure notifications: Value for lockscreen notifications: show all notifications [CHAR LIMIT=60] -->
<string name="lock_screen_notifs_show_full_list">Full list</string>
<!-- Configure notifications: Summary for lockscreen notifications: show all notifications [CHAR LIMIT=100] -->
<string name="lock_screen_notifs_full_list_desc">The current default placement is a full shelf and notification stack.</string>
<!-- Configure notifications: Value for lockscreen notifications: show compact notifications (minimalism on) [CHAR LIMIT=60] -->
<string name="lock_screen_notifs_show_compact">Compact</string>
<!-- Configure notifications: Summary for lockscreen notifications: show compact notifications (minimalism on) [CHAR LIMIT=60] -->
<string name="lock_screen_notifs_compact_desc">New notifications are collapsed into a shelf on your lockscreen.</string>
<!-- Configure notifications: Title for determining which notifications appear on the lock screen [CHAR LIMIT=60] -->
<string name="lock_screen_notifs_title">Notifications on lock screen</string>
@@ -8851,6 +8863,18 @@
<!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Message asking the user how they want their profile notifications to appear when the device is locked [CHAR LIMIT=NONE] -->
<string name="lock_screen_notifications_interstitial_message_profile">When your device is locked, how do you want profile notifications to show?</string>
<!-- Notification Settings > Notifications on lock screen > Title for hiding seen notifications toggle. [CHAR LIMIT=30] -->
<string name="lock_screen_notification_hide_seen_title">Hide seen notifications</string>
<!-- Notification Settings > Notifications on lock screen > Summary for hiding seen notifications toggle. [CHAR LIMIT=30] -->
<string name="lock_screen_notification_hide_seen_summary">Seen notifications are removed from the lock screen.</string>
<!-- Notification Settings > Notifications on lock screen > Title for hiding silent notifications toggle. [CHAR LIMIT=30] -->
<string name="lock_screen_notification_hide_silent_title">Hide silent notifications</string>
<!-- Notification Settings > Notifications on lock screen > Summary for hiding seen notifications toggle. [CHAR LIMIT=30] -->
<string name="lock_screen_notification_hide_silent_summary">Silent notifications and conversations are removed from the lock screen.</string>
<!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Title for the screen asking the user how they want their profile notifications to appear when the device is locked [CHAR LIMIT=30] -->
<string name="lock_screen_notifications_interstitial_title_profile">Profile notifications</string>

36
res/xml/configure_notification_settings.xml
View File

@@ -92,23 +92,31 @@
android:singleLineTitle="false"
android:summary="@string/summary_placeholder" />
<Preference
android:key="lock_screen_notifications_page"
android:order="14"
android:persistent="false"
android:title="@string/lock_screen_notifs_title"
android:fragment="com.android.settings.notification.LockScreenNotificationsPreferencePageFragment"
settings:controller="com.android.settings.notification.LockScreenNotificationsPreferencePageController" />
<com.android.settingslib.RestrictedSwitchPreference
android:key="lock_screen_redact"
android:order="14"
android:order="15"
android:title="@string/lock_screen_notifs_redact"
android:summary="@string/lock_screen_notifs_redact_summary"
settings:controller="com.android.settings.notification.RedactNotificationPreferenceController" />
<com.android.settingslib.RestrictedSwitchPreference
android:key="lock_screen_work_redact"
android:order="15"
android:order="16"
android:title="@string/lock_screen_notifs_redact_work"
android:summary="@string/lock_screen_notifs_redact_work_summary"
settings:controller="com.android.settings.notification.RedactNotificationPreferenceController" />
<SwitchPreferenceCompat
android:key="notification_lockscreen_bypass"
android:order="16"
android:order="17"
android:title="@string/lockscreen_bypass_title"
android:summary="@string/lockscreen_bypass_summary"
settings:searchable="false"
@@ -129,14 +137,14 @@
<Preference
android:fragment="com.android.settings.notification.PoliteNotificationsPreferenceFragment"
android:key="polite_notifications_preference"
android:order="17"
android:order="18"
android:persistent="false"
android:title="@string/notification_polite_title"
settings:controller="com.android.settings.notification.PoliteNotificationsPreferenceController" />
<com.android.settingslib.RestrictedPreference
android:key="zen_mode_notifications"
android:order="18"
android:order="19"
android:title="@string/zen_mode_settings_title"
settings:useAdminDisabledSummary="true"
android:fragment="com.android.settings.notification.zen.ZenModeSettings"
@@ -145,7 +153,7 @@
<SwitchPreferenceCompat
android:key="lock_screen_notif_minimalism"
android:order="19"
android:order="20"
android:title="@string/lock_screen_notif_minimalism"
android:summary="@string/lock_screen_notif_minimalism_summary"
settings:controller="com.android.settings.notification.LockscreenNotificationMinimalismPreferenceController"
@@ -153,7 +161,7 @@
<SwitchPreferenceCompat
android:key="lock_screen_show_only_unseen_notifs"
android:order="20"
android:order="21"
android:title="@string/unseen_notifs_lock_screen"
android:summary="@string/unseen_notifs_lock_screen_summary"
settings:controller="com.android.settings.notification.ShowOnlyUnseenNotificationsOnLockscreenPreferenceController"
@@ -162,7 +170,7 @@
<Preference
android:fragment="com.android.settings.accessibility.FlashNotificationsPreferenceFragment"
android:key="flash_notifications_preference"
android:order="21"
android:order="22"
android:persistent="false"
android:title="@string/flash_notifications_title"
settings:searchable="false"
@@ -170,7 +178,7 @@
<com.android.settingslib.RestrictedPreference
android:key="app_and_notif_cell_broadcast_settings"
android:order="22"
android:order="23"
android:title="@string/cell_broadcast_settings"
settings:useAdminDisabledSummary="true">
<intent
@@ -181,33 +189,33 @@
<SwitchPreferenceCompat
android:key="silent_icons"
android:order="23"
android:order="24"
android:title="@string/silent_notifications_status_bar"
settings:controller="com.android.settings.notification.SilentStatusBarPreferenceController"/>
<SwitchPreferenceCompat
android:key="show_snooze_options"
android:order="24"
android:order="25"
android:title="@string/snooze_options_title"
settings:controller="com.android.settings.notification.SnoozeNotificationPreferenceController" />
<!-- Notification badging -->
<SwitchPreferenceCompat
android:key="notification_badging"
android:order="25"
android:order="26"
android:title="@string/notification_badging_title"
settings:controller="com.android.settings.notification.BadgingNotificationPreferenceController"/>
<!-- Pulse notification light, on devices that support it -->
<SwitchPreferenceCompat
android:key="notification_pulse"
android:order="26"
android:order="27"
android:title="@string/notification_pulse_title"
settings:controller="com.android.settings.notification.PulseNotificationPreferenceController"/>
<SwitchPreferenceCompat
android:key="notification_assistant"
android:order="27"
android:order="28"
android:title="@string/notification_assistant_title"
android:summary="@string/notification_assistant_summary"
settings:controller="com.android.settings.notification.NotificationAssistantPreferenceController"/>

69
res/xml/lock_screen_notifications_settings.xml Normal file
View File

@@ -0,0 +1,69 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
Copyright (C) 2024 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.
-->
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
android:title="@string/lock_screen_notifs_title"
xmlns:settings="http://schemas.android.com/apk/res-auto"
xmlns:app="http://schemas.android.com/apk/res-auto">
<com.android.settingslib.widget.MainSwitchPreference
android:key="lock_screen_notification_global_pref"
android:title="@string/switch_on_text"
settings:controller="com.android.settings.notification.LockScreenNotificationsGlobalPreferenceController"/>
<!-- TODO: replace res with actual illustrations when we have -->
<com.android.settingslib.widget.IllustrationPreference
android:key="compact_illustration"
settings:searchable="false"
android:selectable="false"
settings:dynamicColor="true"/>
<com.android.settingslib.widget.IllustrationPreference
android:key="full_list_illustration"
settings:searchable="false"
android:selectable="false"
settings:dynamicColor="true"/>
<com.android.settingslib.widget.LayoutPreference
android:key="ls_minimalism"
android:selectable="false"
android:layout="@layout/notification_ls_minimalism_selector"
settings:controller="com.android.settings.notification.lockscreen.MinimalismPreferenceController" />
<com.android.settingslib.RestrictedSwitchPreference
android:key="lock_screen_notification_show_sensitive_toggle"
android:title="@string/lock_screen_notifications_summary_hide"
settings:controller="com.android.settings.notification.LockScreenNotificationShowSensitiveToggleController" />
<com.android.settingslib.RestrictedSwitchPreference
android:key="work_profile_show_sensitive_notif_toggle"
android:title="@string/lock_screen_notifications_summary_hide_profile"
settings:controller="com.android.settings.notification.LockScreenNotificationShowSensitiveToggleController" />
<SwitchPreferenceCompat
android:key="lock_screen_notification_hide_seen_toggle"
android:title="@string/lock_screen_notification_hide_seen_title"
android:summary="@string/lock_screen_notification_hide_seen_summary"
settings:controller="com.android.settings.notification.LockScreenNotificationHideSeenToggleController" />
<SwitchPreferenceCompat
android:key="lock_screen_notification_hide_silent_toggle"
android:title="@string/lock_screen_notification_hide_silent_title"
android:summary="@string/lock_screen_notification_hide_silent_summary"
settings:controller="com.android.settings.notification.LockScreenNotificationHideSilentToggleController" />
</PreferenceScreen>

6
res/xml/more_security_privacy_settings.xml
View File

@@ -83,6 +83,12 @@
android:summary="@string/summary_placeholder"
settings:searchable="false"/>
<Preference
android:key="more_security_lock_screen_notifications_page"
android:title="@string/lock_screen_notifs_title"
android:fragment="com.android.settings.notification.LockScreenNotificationsPreferencePageFragment"
settings:controller="com.android.settings.notification.LockScreenNotificationsPreferencePageController" />
<!-- Show media on lock screen -->
<SwitchPreferenceCompat
android:key="privacy_media_controls_lockscreen"

6
res/xml/privacy_dashboard_settings.xml
View File

@@ -91,6 +91,12 @@
android:title="@string/lock_screen_notifs_title"
android:summary="@string/summary_placeholder"/>
<Preference
android:key="privacy_lock_screen_notifications_page"
android:title="@string/lock_screen_notifs_title"
android:fragment="com.android.settings.notification.LockScreenNotificationsPreferencePageFragment"
settings:controller="com.android.settings.notification.LockScreenNotificationsPreferencePageController" />
<!-- Show media on lock screen -->
<SwitchPreferenceCompat
android:key="privacy_media_controls_lockscreen"

7
res/xml/security_lockscreen_settings.xml
View File

@@ -29,6 +29,13 @@
android:summary="@string/summary_placeholder"
settings:keywords="@string/keywords_lock_screen_notif"/>
<Preference
android:key="security_lock_screen_notifications_page"
android:title="@string/lock_screen_notifs_title"
android:summary="@string/summary_placeholder"
android:fragment="com.android.settings.notification.LockScreenNotificationsPreferencePageFragment"
settings:controller="com.android.settings.notification.LockScreenNotificationsPreferencePageController" />
<SwitchPreferenceCompat
android:key="security_display_lockscreen_bypass"
android:title="@string/lockscreen_bypass_title"

137
src/com/android/settings/notification/LockScreenNotificationHideSeenToggleController.java Normal file
View File

@@ -0,0 +1,137 @@
/*
* Copyright (C) 2024 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.settings.notification;
import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleEventObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.server.notification.Flags;
import com.android.settings.core.TogglePreferenceController;
/**
* Controls the toggle that determines whether to hide seen notifications from the lock screen.
* Toggle for setting: Settings.Secure.LOCK_SCREEN_SHOW_ONLY_UNSEEN_NOTIFICATIONS
*/
public class LockScreenNotificationHideSeenToggleController extends TogglePreferenceController
implements LifecycleEventObserver {
private static final int UNSET = 0;
static final int ON = 1;
static final int OFF = 2;
@Nullable private Preference mPreference;
private final ContentResolver mContentResolver;
final ContentObserver mContentObserver = new ContentObserver(
new Handler(Looper.getMainLooper())) {
@Override
public void onChange(boolean selfChange, @Nullable Uri uri) {
if (mPreference == null) return;
updateState(mPreference);
}
};
public LockScreenNotificationHideSeenToggleController(@NonNull Context context,
@NonNull String preferenceKey) {
super(context, preferenceKey);
mContentResolver = context.getContentResolver();
}
@Override
public void displayPreference(@NonNull PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
}
@Override
public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_RESUME) {
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS),
/* notifyForDescendants= */ false, mContentObserver);
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(
Settings.Secure.LOCK_SCREEN_SHOW_ONLY_UNSEEN_NOTIFICATIONS),
/* notifyForDescendants= */ false,
mContentObserver
);
} else if (event == Lifecycle.Event.ON_PAUSE) {
mContentResolver.unregisterContentObserver(mContentObserver);
}
}
@Override
public void updateState(@NonNull Preference preference) {
super.updateState(preference);
setChecked(lockScreenShowOnlyUnseenNotifications());
preference.setVisible(isAvailable());
}
@Override
public int getAvailabilityStatus() {
if (!Flags.notificationMinimalism()) {
return CONDITIONALLY_UNAVAILABLE;
}
if (!lockScreenShowNotification()) {
return CONDITIONALLY_UNAVAILABLE;
}
return AVAILABLE;
}
/**
* @return Whether showing notifications on the lockscreen is enabled.
*/
private boolean lockScreenShowNotification() {
return Settings.Secure.getInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, OFF) == ON;
}
@Override
public boolean isChecked() {
return lockScreenShowOnlyUnseenNotifications();
}
private boolean lockScreenShowOnlyUnseenNotifications() {
return Settings.Secure.getInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_ONLY_UNSEEN_NOTIFICATIONS, UNSET) == ON;
}
@Override
public boolean setChecked(boolean isChecked) {
return Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_ONLY_UNSEEN_NOTIFICATIONS, (isChecked ? ON : OFF));
}
@Override
public int getSliceHighlightMenuRes() {
// not needed because Sliceable is deprecated
return NO_RES;
}
}

133
src/com/android/settings/notification/LockScreenNotificationHideSilentToggleController.java Normal file
View File

@@ -0,0 +1,133 @@
/*
* Copyright (C) 2024 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.settings.notification;
import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleEventObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.core.TogglePreferenceController;
/**
* Controls the toggle that determines whether to show silent notifications when screen locked.
* Toggle for: Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS
*/
public class LockScreenNotificationHideSilentToggleController extends TogglePreferenceController
implements LifecycleEventObserver {
private static final int ON = 1;
private static final int OFF = 0;
@Nullable private Preference mPreference;
private final ContentResolver mContentResolver;
final ContentObserver mContentObserver = new ContentObserver(
new Handler(Looper.getMainLooper())) {
@Override
public void onChange(boolean selfChange, @Nullable Uri uri) {
if (mPreference == null) return;
updateState(mPreference);
}
};
public LockScreenNotificationHideSilentToggleController(@NonNull Context context,
@NonNull String preferenceKey) {
super(context, preferenceKey);
mContentResolver = context.getContentResolver();
}
@Override
public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_RESUME) {
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS),
/* notifyForDescendants= */ false, mContentObserver);
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(
Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS),
/* notifyForDescendants= */ false,
mContentObserver
);
} else if (event == Lifecycle.Event.ON_PAUSE) {
mContentResolver.unregisterContentObserver(mContentObserver);
}
}
@Override
public void displayPreference(@NonNull PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
}
@Override
public void updateState(@NonNull Preference preference) {
super.updateState(preference);
setChecked(hideSilentNotificationsWhenLocked());
preference.setVisible(isAvailable());
}
private boolean hideSilentNotificationsWhenLocked() {
return Settings.Secure.getInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, OFF) == OFF;
}
@Override
public int getAvailabilityStatus() {
if (!lockScreenShowNotification()) {
return CONDITIONALLY_UNAVAILABLE;
}
return AVAILABLE;
}
/**
* @return Whether showing notifications on the lockscreen is enabled.
*/
private boolean lockScreenShowNotification() {
return Settings.Secure.getInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, OFF) == ON;
}
@Override
public boolean isChecked() {
return hideSilentNotificationsWhenLocked();
}
@Override
public boolean setChecked(boolean isChecked) {
return Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, (isChecked ? OFF : ON));
}
@Override
public int getSliceHighlightMenuRes() {
// not needed since it's not sliceable
return NO_RES;
}
}

8
src/com/android/settings/notification/LockScreenNotificationPreferenceController.java
View File

@@ -37,6 +37,7 @@ import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.internal.widget.LockPatternUtils;
import com.android.server.notification.Flags;
import com.android.settings.R;
import com.android.settings.RestrictedListPreference;
import com.android.settings.Utils;
@@ -94,6 +95,13 @@ public class LockScreenNotificationPreferenceController extends AbstractPreferen
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
// Hide the preference when the lock screen notification page shows
if (Flags.notificationLockScreenSettings()) {
setVisible(screen, mSettingKey, false);
setVisible(screen, mWorkSettingKey, false);
setVisible(screen, mWorkSettingCategoryKey, false);
return;
}
mLockscreen = screen.findPreference(mSettingKey);
if (mLockscreen == null) {
Log.i(TAG, "Preference not found: " + mSettingKey);

222
src/com/android/settings/notification/LockScreenNotificationShowSensitiveToggleController.java Normal file
View File

@@ -0,0 +1,222 @@
/*
* Copyright (C) 2024 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.settings.notification;
import static android.app.admin.DevicePolicyManager.KEYGUARD_DISABLE_SECURE_NOTIFICATIONS;
import static android.app.admin.DevicePolicyManager.KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS;
import android.app.KeyguardManager;
import android.content.ContentResolver;
import android.content.Context;
import android.content.pm.UserInfo;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleEventObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.core.TogglePreferenceController;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.RestrictedLockUtils;
import com.android.settingslib.RestrictedLockUtilsInternal;
import com.android.settingslib.RestrictedSwitchPreference;
import java.util.List;
/**
* Controls the toggle that determines whether to show sensitive notifications on the lock screen
* when locked.
* Toggle for: Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS
*/
public class LockScreenNotificationShowSensitiveToggleController
extends TogglePreferenceController implements LifecycleEventObserver {
private static final int ON = 1;
private static final int OFF = 0;
@VisibleForTesting
static final String KEY_SHOW_SENSITIVE = "lock_screen_notification_show_sensitive_toggle";
@VisibleForTesting
static final String KEY_SHOW_SENSITIVE_WORK_PROFILE =
"work_profile_show_sensitive_notif_toggle";
@Nullable private RestrictedSwitchPreference mPreference;
private final ContentResolver mContentResolver;
private UserManager mUserManager;
private KeyguardManager mKeyguardManager;
@VisibleForTesting
int mWorkProfileUserId;
final ContentObserver mContentObserver = new ContentObserver(
new Handler(Looper.getMainLooper())) {
@Override
public void onChange(boolean selfChange, @Nullable Uri uri) {
updateState(mPreference);
}
};
public LockScreenNotificationShowSensitiveToggleController(@NonNull Context context,
@NonNull String preferenceKey) {
super(context, preferenceKey);
mContentResolver = context.getContentResolver();
mUserManager = context.getSystemService(UserManager.class);
mKeyguardManager = context.getSystemService(KeyguardManager.class);
mWorkProfileUserId = UserHandle.myUserId();
final List<UserInfo> profiles = mUserManager.getProfiles(UserHandle.myUserId());
for (UserInfo profile: profiles) {
if (profile.isManagedProfile()
&& profile.getUserHandle().getIdentifier() != UserHandle.myUserId()) {
mWorkProfileUserId = profile.getUserHandle().getIdentifier();
}
}
}
@Override
public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_RESUME) {
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS),
/* notifyForDescendants= */ false, mContentObserver);
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(
Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS),
/* notifyForDescendants= */ false,
mContentObserver
);
} else if (event == Lifecycle.Event.ON_PAUSE) {
mContentResolver.unregisterContentObserver(mContentObserver);
}
}
@Override
public void displayPreference(@NonNull PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
int userId = getUserId();
if (mPreference != null && userId != UserHandle.USER_NULL) {
mPreference.setDisabledByAdmin(getEnforcedAdmin(userId));
}
}
private RestrictedLockUtils.EnforcedAdmin getEnforcedAdmin(int userId) {
RestrictedLockUtils.EnforcedAdmin admin =
RestrictedLockUtilsInternal.checkIfKeyguardFeaturesDisabled(
mContext, KEYGUARD_DISABLE_SECURE_NOTIFICATIONS, userId);
if (admin != null) {
return admin;
}
admin = RestrictedLockUtilsInternal.checkIfKeyguardFeaturesDisabled(
mContext, KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS, userId);
return admin;
}
private int getUserId() {
return KEY_SHOW_SENSITIVE.equals(getPreferenceKey())
? UserHandle.myUserId() : mWorkProfileUserId;
}
@Override
public void updateState(@Nullable Preference preference) {
if (preference == null) return;
setChecked(showSensitiveContentOnlyWhenUnlocked());
preference.setVisible(isAvailable());
}
@Override
public int getAvailabilityStatus() {
// hide setting if no lock screen notification
if (!lockScreenShowNotification()) {
return CONDITIONALLY_UNAVAILABLE;
}
// hide setting if no screen lock
if (!isLockScreenSecure()) {
return CONDITIONALLY_UNAVAILABLE;
}
// For the work profile toggle
if (KEY_SHOW_SENSITIVE_WORK_PROFILE.equals(getPreferenceKey())) {
// hide work profile setting if no work profile
if (mWorkProfileUserId == UserHandle.myUserId()) {
return CONDITIONALLY_UNAVAILABLE;
}
// specifically the work profile setting requires the work profile to be unlocked
if (mKeyguardManager.isDeviceLocked(mWorkProfileUserId)) {
return CONDITIONALLY_UNAVAILABLE;
}
}
return AVAILABLE;
}
/**
* @return Whether showing notifications on the lockscreen is enabled.
*/
private boolean lockScreenShowNotification() {
return Settings.Secure.getInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, ON) != OFF;
}
@Override
public boolean isChecked() {
return showSensitiveContentOnlyWhenUnlocked();
}
private boolean showSensitiveContentOnlyWhenUnlocked() {
int userId = getUserId();
if (!isLockScreenSecure()) return false;
if (getEnforcedAdmin(userId) != null) return true;
return Settings.Secure.getIntForUser(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, ON, userId) == OFF;
}
@Override
public boolean setChecked(boolean isChecked) {
return Settings.Secure.putIntForUser(
mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
(isChecked ? OFF : ON), getUserId()
);
}
private boolean isLockScreenSecure() {
return FeatureFactory.getFeatureFactory()
.getSecurityFeatureProvider()
.getLockPatternUtils(mContext)
.isSecure(UserHandle.myUserId());
}
@Override
public int getSliceHighlightMenuRes() {
// not needed since it's not sliceable
return NO_RES;
}
}

117
src/com/android/settings/notification/LockScreenNotificationsGlobalPreferenceController.java Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright (C) 2024 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.settings.notification;
import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleEventObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.server.notification.Flags;
import com.android.settings.widget.SettingsMainSwitchPreferenceController;
public class LockScreenNotificationsGlobalPreferenceController
extends SettingsMainSwitchPreferenceController
implements LifecycleEventObserver {
public static final int ON = 1;
public static final int OFF = 0;
private final ContentResolver mContentResolver;
private final ContentObserver mContentObserver;
@Nullable private Preference mPreference;
public LockScreenNotificationsGlobalPreferenceController(
@NonNull Context context,
@NonNull String preferenceKey
) {
super(context, preferenceKey);
mContentResolver = context.getContentResolver();
mContentObserver = new ContentObserver(new Handler(Looper.getMainLooper())) {
@Override
public void onChange(boolean selfChange, @Nullable Uri uri) {
if (mPreference == null) return;
updateState(mPreference);
}
};
}
@Override
public void displayPreference(@NonNull PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
}
@Override
public void updateState(@NonNull Preference preference) {
super.updateState(preference);
setChecked(lockScreenShowNotifications());
}
@Override
public int getAvailabilityStatus() {
// TODO: b/367455695 - remove this when the feature flag is removed!
return Flags.notificationLockScreenSettings() ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
}
@Override
public boolean isChecked() {
return lockScreenShowNotifications();
}
private boolean lockScreenShowNotifications() {
return Settings.Secure.getInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, OFF) == ON;
}
@Override
public boolean setChecked(boolean isChecked) {
return Settings.Secure.putInt(mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, (isChecked ? ON : OFF));
}
@Override
public int getSliceHighlightMenuRes() {
// not needed since it's not sliceable
return NO_RES;
}
@Override
public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_RESUME) {
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS),
/* notifyForDescendants= */ false,
mContentObserver
);
} else {
mContentResolver.unregisterContentObserver(mContentObserver);
}
}
}

40
src/com/android/settings/notification/LockScreenNotificationsPreferencePageController.java Normal file
View File

@@ -0,0 +1,40 @@
/*
* Copyright (C) 2024 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.settings.notification;
import android.content.Context;
import com.android.server.notification.Flags;
import com.android.settings.core.BasePreferenceController;
// TODO(b/367455695): remove controller when the feature flag is removed!
/**
* Controller for lock screen notifications settings page.
*/
public class LockScreenNotificationsPreferencePageController extends BasePreferenceController {
public LockScreenNotificationsPreferencePageController(Context context, String preferenceKey) {
super(context, preferenceKey);
}
@Override
public int getAvailabilityStatus() {
return Flags.notificationLockScreenSettings() ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
}
}

56
src/com/android/settings/notification/LockScreenNotificationsPreferencePageFragment.java Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright (C) 2024 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.settings.notification;
import android.app.settings.SettingsEnums;
import android.content.Context;
import com.android.server.notification.Flags;
import com.android.settings.R;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settingslib.search.SearchIndexable;
/**
* Fragment for notifications on lock screen preference page.
*/
@SearchIndexable
public class LockScreenNotificationsPreferencePageFragment extends DashboardFragment {
@Override
public int getMetricsCategory() {
//TODO(b/367455695): create a new metrics category
return SettingsEnums.SETTINGS_LOCK_SCREEN_PREFERENCES;
}
@Override
protected int getPreferenceScreenResId() {
return R.xml.lock_screen_notifications_settings;
}
@Override
protected String getLogTag() {
return "LockScreenNotificationsPreferenceFragment";
}
public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
new BaseSearchIndexProvider(R.xml.lock_screen_notifications_settings) {
@Override
protected boolean isPageSearchEnabled(Context context) {
return Flags.notificationLockScreenSettings();
}
};
}

4
src/com/android/settings/notification/LockscreenNotificationMinimalismPreferenceController.java
View File

@@ -56,6 +56,10 @@ public class LockscreenNotificationMinimalismPreferenceController
@Override
public int getAvailabilityStatus() {
// Hide when the notifications on lock screen settings page flag is enabled.
if (Flags.notificationLockScreenSettings()) {
return CONDITIONALLY_UNAVAILABLE;
}
if (!Flags.notificationMinimalism()) {
return CONDITIONALLY_UNAVAILABLE;
}

7
src/com/android/settings/notification/PoliteNotificationsPreferenceController.java
View File

@@ -18,16 +18,19 @@ package com.android.settings.notification;
import android.content.Context;
import androidx.annotation.NonNull;
import com.android.server.notification.Flags;
import com.android.settings.core.BasePreferenceController;
// TODO: b/291897570 - remove controller when the feature flag is removed!
// TODO(b/330606963): remove controller when the feature flag is removed!
/**
* Controller for polite notifications settings page.
*/
public class PoliteNotificationsPreferenceController extends BasePreferenceController {
public PoliteNotificationsPreferenceController(Context context, String preferenceKey) {
public PoliteNotificationsPreferenceController(@NonNull Context context,
@NonNull String preferenceKey) {
super(context, preferenceKey);
}

6
src/com/android/settings/notification/RedactNotificationPreferenceController.java
View File

@@ -33,6 +33,7 @@ import android.provider.Settings;
import androidx.preference.PreferenceScreen;
import com.android.internal.widget.LockPatternUtils;
import com.android.server.notification.Flags;
import com.android.settings.R;
import com.android.settings.core.TogglePreferenceController;
import com.android.settings.overlay.FeatureFactory;
@@ -120,6 +121,11 @@ public class RedactNotificationPreferenceController extends TogglePreferenceCont
@Override
public int getAvailabilityStatus() {
// Hide when the notifications on lock screen settings page flag is enabled.
if (Flags.notificationLockScreenSettings()) {
return CONDITIONALLY_UNAVAILABLE;
}
// hide work profile setting if no work profile
if (KEY_LOCKSCREEN_WORK_PROFILE_REDACT.equals(getPreferenceKey())
&& mProfileUserId == UserHandle.myUserId()) {

4
src/com/android/settings/notification/ShowOnLockScreenNotificationPreferenceController.java
View File

@@ -26,6 +26,7 @@ import android.provider.Settings;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.server.notification.Flags;
import com.android.settings.R;
import com.android.settings.RestrictedListPreference;
import com.android.settings.core.PreferenceControllerMixin;
@@ -63,7 +64,8 @@ public class ShowOnLockScreenNotificationPreferenceController extends AbstractPr
@Override
public boolean isAvailable() {
return true;
// When notificationLockScreenSettings is enabled, show the lock screen notif settings page
return !Flags.notificationLockScreenSettings();
}
@Override

4
src/com/android/settings/notification/ShowOnlyUnseenNotificationsOnLockscreenPreferenceController.java
View File

@@ -57,6 +57,10 @@ public class ShowOnlyUnseenNotificationsOnLockscreenPreferenceController
@Override
public int getAvailabilityStatus() {
// Hide when the notifications on lock screen page flag is enabled.
if (Flags.notificationLockScreenSettings()) {
return CONDITIONALLY_UNAVAILABLE;
}
if (Flags.notificationMinimalism()) {
if (!isNotifOnLockScreenEnabled()) {
return DISABLED_DEPENDENT_SETTING;

196
src/com/android/settings/notification/lockscreen/MinimalismPreferenceController.java Normal file
View File

@@ -0,0 +1,196 @@
/*
* Copyright (C) 2024 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.settings.notification.lockscreen;
import static android.provider.Settings.Secure.LOCK_SCREEN_NOTIFICATION_MINIMALISM;
import static android.provider.Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS;
import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleEventObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.PreferenceScreen;
import com.android.server.notification.Flags;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.widget.IllustrationPreference;
import com.android.settingslib.widget.LayoutPreference;
import java.util.HashMap;
import java.util.Map;
public class MinimalismPreferenceController
extends BasePreferenceController
implements LifecycleEventObserver {
private static final int LS_SHOW_NOTIF_ON = 1;
private static final int LS_SHOW_NOTIF_OFF = 0;
private static final int LS_MINIMALISM_OFF = 0;
private static final int LS_MINIMALISM_ON = 1;
private static final String KEY_MINIMALISM_PREFERENCE = "ls_minimalism";
private static final String KEY_FULL_LIST_ILLUSTRATION = "full_list_illustration";
private static final String KEY_COMPACT_ILLUSTRATION = "compact_illustration";
private static final Uri URI_LOCK_SCREEN_NOTIFICATION_MINIMALISM =
Settings.Secure.getUriFor(LOCK_SCREEN_NOTIFICATION_MINIMALISM);
private static final Uri URI_LOCK_SCREEN_SHOW_NOTIFICATIONS =
Settings.Secure.getUriFor(LOCK_SCREEN_SHOW_NOTIFICATIONS);
@Nullable private LayoutPreference mPreference;
@Nullable private TextView mDescView;
private Map<Integer, LinearLayout> mButtons = new HashMap<>();
private Map<Integer, IllustrationPreference> mIllustrations = new HashMap<>();
private final Map<Integer, Integer> mDescriptionTexts = Map.ofEntries(
Map.entry(LS_MINIMALISM_OFF, R.string.lock_screen_notifs_full_list_desc),
Map.entry(LS_MINIMALISM_ON, R.string.lock_screen_notifs_compact_desc)
);
private final ContentResolver mContentResolver;
final ContentObserver mContentObserver = new ContentObserver(
new Handler(Looper.getMainLooper())) {
@Override
public void onChange(boolean selfChange, @Nullable Uri uri) {
refreshState(uri);
}
};
public MinimalismPreferenceController(@NonNull Context context, @NonNull String preferenceKey) {
super(context, preferenceKey);
mContentResolver = context.getContentResolver();
}
@Override
public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_RESUME) {
mContentResolver.registerContentObserver(
URI_LOCK_SCREEN_NOTIFICATION_MINIMALISM,
/* notifyForDescendants= */ false,
mContentObserver
);
mContentResolver.registerContentObserver(
URI_LOCK_SCREEN_SHOW_NOTIFICATIONS,
/* notifyForDescendants= */ false,
mContentObserver
);
} else if (event == Lifecycle.Event.ON_PAUSE) {
mContentResolver.unregisterContentObserver(mContentObserver);
}
}
@Override
public int getAvailabilityStatus() {
if (!Flags.notificationMinimalism()) {
return CONDITIONALLY_UNAVAILABLE;
}
if (!lockScreenShowNotification()) {
return CONDITIONALLY_UNAVAILABLE;
}
return AVAILABLE;
}
/**
* @return Whether showing notifications on the lockscreen is enabled.
*/
private boolean lockScreenShowNotification() {
return Settings.Secure.getInt(
mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS,
LS_SHOW_NOTIF_OFF
) == LS_SHOW_NOTIF_ON;
}
@Override
public void displayPreference(@NonNull PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(KEY_MINIMALISM_PREFERENCE);
mDescView = mPreference.findViewById(R.id.notif_ls_style_desc);
mButtons = Map.ofEntries(
Map.entry(LS_MINIMALISM_OFF,
mPreference.findViewById(R.id.button_full)),
Map.entry(LS_MINIMALISM_ON,
mPreference.findViewById(R.id.button_compact))
);
mIllustrations = Map.ofEntries(
Map.entry(LS_MINIMALISM_OFF,
screen.findPreference(KEY_FULL_LIST_ILLUSTRATION)),
Map.entry(LS_MINIMALISM_ON,
screen.findPreference(KEY_COMPACT_ILLUSTRATION))
);
mButtons.forEach((value, button) -> button.setOnClickListener(v ->
Settings.Secure.putInt(
mContext.getContentResolver(),
Settings.Secure.LOCK_SCREEN_NOTIFICATION_MINIMALISM,
value
)
));
refreshState(URI_LOCK_SCREEN_NOTIFICATION_MINIMALISM);
}
private void highlightButton(int currentValue) {
mButtons.forEach((value, button) -> button.setSelected(currentValue == value));
}
private void highlightIllustration(int currentValue) {
mIllustrations.forEach((value, preference)
-> preference.setVisible(currentValue == value));
}
private void highlightDescription(int value) {
if (mDescView == null) return;
Integer descStringId = mDescriptionTexts.get(value);
if (descStringId != null) {
mDescView.setText(descStringId);
}
}
private int getCurrentMinimalismValue() {
return Settings.Secure.getInt(mContext.getContentResolver(),
LOCK_SCREEN_NOTIFICATION_MINIMALISM, LS_MINIMALISM_ON);
}
private void refreshState(@Nullable Uri uri) {
if (mPreference == null) return;
if (URI_LOCK_SCREEN_SHOW_NOTIFICATIONS.equals(uri) && !lockScreenShowNotification()) {
// hide all preferences when showing notifications on lock screen is disabled
mIllustrations.forEach((value, preference)
-> preference.setVisible(false));
mPreference.setVisible(false);
} else {
mPreference.setVisible(isAvailable());
int currentValue = getCurrentMinimalismValue();
highlightButton(currentValue);
highlightIllustration(currentValue);
highlightDescription(currentValue);
}
}
}

354
tests/robotests/src/com/android/settings/notification/LockScreenNotificationShowSensitiveToggleControllerTest.java Normal file
View File

@@ -0,0 +1,354 @@
/*
* Copyright (C) 2019 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.settings.notification;
import static android.app.admin.DevicePolicyManager.KEYGUARD_DISABLE_SECURE_NOTIFICATIONS;
import static android.app.admin.DevicePolicyManager.KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS;
import static android.provider.Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS;
import static android.provider.Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS;
import static com.android.settings.core.BasePreferenceController.AVAILABLE;
import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
import android.app.KeyguardManager;
import android.app.admin.DevicePolicyManager;
import android.content.Context;
import android.content.pm.UserInfo;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
import androidx.preference.PreferenceScreen;
import com.android.internal.widget.LockPatternUtils;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal;
import com.android.settings.testutils.shadow.ShadowUtils;
import com.android.settingslib.RestrictedSwitchPreference;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import java.util.Arrays;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = {
ShadowUtils.class,
ShadowRestrictedLockUtilsInternal.class,
})
public class LockScreenNotificationShowSensitiveToggleControllerTest {
@Mock
private DevicePolicyManager mDpm;
@Mock
UserManager mUm;
@Mock
KeyguardManager mKm;
@Mock
private PreferenceScreen mScreen;
@Mock
private LockPatternUtils mLockPatternUtils;
@Mock
private Context mMockContext;
private Context mContext;
private LockScreenNotificationShowSensitiveToggleController mController;
private LockScreenNotificationShowSensitiveToggleController mWorkController;
private RestrictedSwitchPreference mPreference;
private RestrictedSwitchPreference mWorkPreference;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
FakeFeatureFactory featureFactory = FakeFeatureFactory.setupForTest();
when(featureFactory.securityFeatureProvider.getLockPatternUtils(mMockContext))
.thenReturn(mLockPatternUtils);
when(mMockContext.getContentResolver()).thenReturn(mContext.getContentResolver());
when(mMockContext.getSystemService(UserManager.class)).thenReturn(mUm);
when(mMockContext.getSystemService(DevicePolicyManager.class)).thenReturn(mDpm);
when(mMockContext.getSystemService(KeyguardManager.class)).thenReturn(mKm);
when(mUm.getProfiles(anyInt())).thenReturn(Arrays.asList(new UserInfo(0, "", 0)));
mController = new LockScreenNotificationShowSensitiveToggleController(
mMockContext,
LockScreenNotificationShowSensitiveToggleController.KEY_SHOW_SENSITIVE
);
mPreference = new RestrictedSwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
when(mScreen.findPreference(
mController.getPreferenceKey())).thenReturn(mPreference);
when(mUm.getProfiles(anyInt())).thenReturn(Arrays.asList(
new UserInfo(5, "", 0),
new UserInfo(10, "", UserInfo.FLAG_MANAGED_PROFILE | UserInfo.FLAG_PROFILE)));
mWorkController = new LockScreenNotificationShowSensitiveToggleController(
mMockContext,
LockScreenNotificationShowSensitiveToggleController.KEY_SHOW_SENSITIVE_WORK_PROFILE
);
mWorkPreference = new RestrictedSwitchPreference(mContext);
mWorkPreference.setKey(mWorkController.getPreferenceKey());
when(mScreen.findPreference(
mWorkController.getPreferenceKey())).thenReturn(mWorkPreference);
}
@After
public void tearDown() {
ShadowRestrictedLockUtilsInternal.reset();
}
@Test
public void profileUserIds() {
assertThat(mController.mWorkProfileUserId).isEqualTo(0);
assertThat(mWorkController.mWorkProfileUserId).isEqualTo(10);
}
@Test
public void getAvailabilityStatus_noSecureLockscreen() {
when(mLockPatternUtils.isSecure(anyInt())).thenReturn(false);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 0);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 10);
assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
assertThat(mWorkController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
}
@Test
public void getAvailabilityStatus_noWorkProfile() {
// reset controllers with no work profile
when(mUm.getProfiles(anyInt())).thenReturn(Arrays.asList(
new UserInfo(UserHandle.myUserId(), "", 0)));
mWorkController = new LockScreenNotificationShowSensitiveToggleController(
mMockContext,
LockScreenNotificationShowSensitiveToggleController.KEY_SHOW_SENSITIVE_WORK_PROFILE
);
mController = new LockScreenNotificationShowSensitiveToggleController(mMockContext,
LockScreenNotificationShowSensitiveToggleController.KEY_SHOW_SENSITIVE);
// should otherwise show
when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 0);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
assertThat(mWorkController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
}
@Test
public void displayPreference_adminSaysNoRedaction() {
ShadowRestrictedLockUtilsInternal.setKeyguardDisabledFeatures(
KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS);
mController.displayPreference(mScreen);
assertThat(mPreference.isDisabledByAdmin()).isTrue();
mWorkController.displayPreference(mScreen);
assertThat(mWorkPreference.isDisabledByAdmin()).isTrue();
}
@Test
public void displayPreference_adminSaysNoSecure() {
ShadowRestrictedLockUtilsInternal.setKeyguardDisabledFeatures(
KEYGUARD_DISABLE_SECURE_NOTIFICATIONS);
mController.displayPreference(mScreen);
assertThat(mPreference.isDisabledByAdmin()).isTrue();
mWorkController.displayPreference(mScreen);
assertThat(mWorkPreference.isDisabledByAdmin()).isTrue();
}
@Test
public void displayPreference() {
ShadowRestrictedLockUtilsInternal.setKeyguardDisabledFeatures(0);
mController.displayPreference(mScreen);
assertThat(mPreference.isDisabledByAdmin()).isFalse();
mWorkController.displayPreference(mScreen);
assertThat(mWorkPreference.isDisabledByAdmin()).isFalse();
}
@Test
public void getAvailabilityStatus_adminSaysNoNotifications() {
when(mDpm.getKeyguardDisabledFeatures(eq(null), anyInt())).thenReturn(
KEYGUARD_DISABLE_SECURE_NOTIFICATIONS);
// should show
when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 0);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 10);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
assertThat(mWorkController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
}
@Test
public void getAvailabilityStatus_noNotifications() {
when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
0, 0);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
0, 10);
assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
assertThat(mWorkController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
}
@Test
public void getAvailabilityStatus_workProfileLocked() {
// should otherwise show
when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 0);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 10);
when(mKm.isDeviceLocked(10)).thenReturn(true);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
assertThat(mWorkController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
}
@Test
public void getAvailabilityStatus_show() {
// should show
when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 0);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_SHOW_NOTIFICATIONS,
1, 10);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
assertThat(mWorkController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
}
@Test
public void isChecked() {
when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
0, 0);
assertThat(mController.isChecked()).isTrue();
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
1, 0);
assertThat(mController.isChecked()).isFalse();
}
@Test
public void isChecked_work() {
when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
0, 10);
assertThat(mWorkController.isChecked()).isTrue();
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
1, 10);
assertThat(mWorkController.isChecked()).isFalse();
}
@Test
public void isChecked_admin() {
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
1, 0);
ShadowRestrictedLockUtilsInternal.setKeyguardDisabledFeatures(
KEYGUARD_DISABLE_SECURE_NOTIFICATIONS);
assertThat(mController.isChecked()).isFalse();
}
@Test
public void setChecked_false() throws Exception {
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
0, 0);
mController.setChecked(false);
assertThat(Settings.Secure.getIntForUser(
mContext.getContentResolver(), LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 0))
.isEqualTo(1);
}
@Test
public void setChecked_workProfile_true() throws Exception {
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
1, 10);
mWorkController.setChecked(true);
assertThat(Settings.Secure.getIntForUser(
mContext.getContentResolver(), LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 10))
.isEqualTo(0);
}
@Test
public void setChecked_true() throws Exception {
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
1, 0);
Settings.Secure.putIntForUser(mContext.getContentResolver(),
LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
1, 10);
mController.setChecked(true);
mWorkController.setChecked(true);
assertThat(Settings.Secure.getIntForUser(
mContext.getContentResolver(), LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 10))
.isEqualTo(0);
assertThat(Settings.Secure.getIntForUser(
mContext.getContentResolver(), LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 0))
.isEqualTo(0);
}
}

69
tests/robotests/src/com/android/settings/notification/LockScreenNotificationsPreferencePageControllerTest.java Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright (C) 2024 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.settings.notification;
import static com.google.common.truth.Truth.assertThat;
import android.platform.test.flag.junit.SetFlagsRule;
import com.android.server.notification.Flags;
import com.android.settings.core.BasePreferenceController;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
// TODO(b/367455695): remove test when feature flag is cleaned
@RunWith(RobolectricTestRunner.class)
public class LockScreenNotificationsPreferencePageControllerTest {
@Rule
public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
private static final String PREFERENCE_KEY = "lock_screen_notifications_page";
private LockScreenNotificationsPreferencePageController mController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mController = new LockScreenNotificationsPreferencePageController(
RuntimeEnvironment.application,
PREFERENCE_KEY);
}
@Test
public void isAvailable_flagEnabled_shouldReturnTrue() {
mSetFlagsRule.enableFlags(Flags.FLAG_NOTIFICATION_LOCK_SCREEN_SETTINGS);
assertThat(mController.isAvailable()).isTrue();
assertThat(mController.getAvailabilityStatus()).isEqualTo(
BasePreferenceController.AVAILABLE);
}
@Test
public void isAvailable_flagDisabled_shouldReturnFalse() {
mSetFlagsRule.disableFlags(Flags.FLAG_NOTIFICATION_LOCK_SCREEN_SETTINGS);
assertThat(mController.isAvailable()).isFalse();
assertThat(mController.getAvailabilityStatus()).isEqualTo(
BasePreferenceController.CONDITIONALLY_UNAVAILABLE);
}
}