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

Add auto lock preference inside private space settings

Browse Source 
This includes below changes
- Adds perference for Auto Lock settings inside private space settings page.
- Feaure is behind flag
android.multiuser.support_autolock_for_private_space

Screenshots:
go/ss/ZCaYGWMDdH8bQNz.png
go/ss/AxnD8DviiT5hhkW.png
go/ss/9TMYmacyiVhyexB.png
go/ss/6SzhkGfTbDYVUVE.png

Bug: 312893140
Test: atest AutoLockPreferenceControllerTest, atest AutoLockPreferenceControllerTest

Change-Id: I95beb9d71c709002e17307e612c60b2f5087290b
This commit is contained in:
josephpv
2023-12-11 23:44:27 +00:00
committed by Joseph Vincent
parent 5245ebfd4a
commit 099ae32943
10 changed files with 659 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/com/android/settings/privatespace/PrivateSpaceMaintainer.java
View File

@@ -18,6 +18,8 @@ package com.android.settings.privatespace;
import static android.os.UserManager.USER_TYPE_PROFILE_PRIVATE;
import static android.provider.Settings.Secure.HIDE_PRIVATESPACE_ENTRY_POINT;
import static android.provider.Settings.Secure.PRIVATE_SPACE_AUTO_LOCK;
import static android.provider.Settings.Secure.PRIVATE_SPACE_AUTO_LOCK_NEVER;
import static android.provider.Settings.Secure.USER_SETUP_COMPLETE;
import android.app.ActivityManager;
@@ -46,7 +48,6 @@ import java.util.List;
/** A class to help with the creation / deletion of Private Space */
public class PrivateSpaceMaintainer {
private static final String TAG = "PrivateSpaceMaintainer";
@GuardedBy("this")
private static PrivateSpaceMaintainer sPrivateSpaceMaintainer;
@@ -59,6 +60,9 @@ public class PrivateSpaceMaintainer {
/** This is the default value for the hide private space entry point settings. */
public static final int HIDE_PRIVATE_SPACE_ENTRY_POINT_DISABLED_VAL = 0;
public static final int HIDE_PRIVATE_SPACE_ENTRY_POINT_ENABLED_VAL = 1;
/** Default value for private space auto lock settings. */
@Settings.Secure.PrivateSpaceAutoLockOption
public static final int PRIVATE_SPACE_AUTO_LOCK_DEFAULT_VAL = PRIVATE_SPACE_AUTO_LOCK_NEVER;
public enum ErrorDeletingPrivateSpace {
DELETE_PS_ERROR_NONE,
@@ -223,6 +227,14 @@ public class PrivateSpaceMaintainer {
Settings.Secure.putInt(mContext.getContentResolver(), HIDE_PRIVATESPACE_ENTRY_POINT, value);
}
/** Sets the setting for private space auto lock option. */
public void setPrivateSpaceAutoLockSetting(
@Settings.Secure.PrivateSpaceAutoLockOption int value) {
if (isPrivateSpaceAutoLockSupported()) {
Settings.Secure.putInt(mContext.getContentResolver(), PRIVATE_SPACE_AUTO_LOCK, value);
}
}
/** @return the setting to show PS entry point. */
public int getHidePrivateSpaceEntryPointSetting() {
return Settings.Secure.getInt(
@@ -231,6 +243,18 @@ public class PrivateSpaceMaintainer {
HIDE_PRIVATE_SPACE_ENTRY_POINT_DISABLED_VAL);
}
/** @return the setting for PS auto lock option. */
@Settings.Secure.PrivateSpaceAutoLockOption
public int getPrivateSpaceAutoLockSetting() {
if (isPrivateSpaceAutoLockSupported()) {
return Settings.Secure.getInt(
mContext.getContentResolver(),
PRIVATE_SPACE_AUTO_LOCK,
PRIVATE_SPACE_AUTO_LOCK_DEFAULT_VAL);
}
return PRIVATE_SPACE_AUTO_LOCK_DEFAULT_VAL;
}
/**
* Returns true if private space exists and quiet mode is successfully enabled, otherwise
* returns false
@@ -264,6 +288,7 @@ public class PrivateSpaceMaintainer {
private void resetPrivateSpaceSettings() {
setHidePrivateSpaceEntryPointSetting(HIDE_PRIVATE_SPACE_ENTRY_POINT_DISABLED_VAL);
setPrivateSpaceAutoLockSetting(PRIVATE_SPACE_AUTO_LOCK_DEFAULT_VAL);
}
/**
@@ -275,4 +300,9 @@ public class PrivateSpaceMaintainer {
Settings.Secure.putIntForUser(mContext.getContentResolver(), USER_SETUP_COMPLETE,
1, mUserHandle.getIdentifier());
}
private boolean isPrivateSpaceAutoLockSupported() {
return android.os.Flags.allowPrivateProfile()
&& android.multiuser.Flags.supportAutolockForPrivateSpace();
}
}

58
src/com/android/settings/privatespace/autolock/AutoLockPreferenceController.java Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright (C) 2023 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.privatespace.autolock;
import android.content.Context;
import android.util.Log;
import androidx.annotation.NonNull;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import com.android.settings.privatespace.PrivateSpaceMaintainer;
public class AutoLockPreferenceController extends BasePreferenceController {
private static final String TAG = "AutoLockPreferenceCtrl";
private final CharSequence[] mAutoLockRadioOptions;
private final PrivateSpaceMaintainer mPrivateSpaceMaintainer;
public AutoLockPreferenceController(@NonNull Context context, @NonNull String key) {
super(context, key);
mPrivateSpaceMaintainer = PrivateSpaceMaintainer.getInstance(context);
mAutoLockRadioOptions =
context.getResources().getStringArray(R.array.private_space_auto_lock_options);
}
@Override
public int getAvailabilityStatus() {
return android.os.Flags.allowPrivateProfile()
&& android.multiuser.Flags.supportAutolockForPrivateSpace()
? AVAILABLE
: UNSUPPORTED_ON_DEVICE;
}
@NonNull
@Override
public CharSequence getSummary() {
try {
return mAutoLockRadioOptions[mPrivateSpaceMaintainer.getPrivateSpaceAutoLockSetting()];
} catch (ArrayIndexOutOfBoundsException exception) {
Log.e(TAG, "Invalid private space auto lock setting value" + exception.getMessage());
}
return mAutoLockRadioOptions[PrivateSpaceMaintainer.PRIVATE_SPACE_AUTO_LOCK_DEFAULT_VAL];
}
}

148
src/com/android/settings/privatespace/autolock/AutoLockSettingsFragment.java Normal file
View File

@@ -0,0 +1,148 @@
/*
* Copyright (C) 2023 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.privatespace.autolock;
import android.app.settings.SettingsEnums;
import android.content.Context;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.provider.Settings;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.privatespace.PrivateSpaceMaintainer;
import com.android.settings.widget.RadioButtonPickerFragment;
import com.android.settingslib.widget.CandidateInfo;
import com.android.settingslib.widget.TopIntroPreference;
import java.util.ArrayList;
import java.util.List;
public class AutoLockSettingsFragment extends RadioButtonPickerFragment {
private static final String TAG = "PSAutoLockSetting";
private PrivateSpaceMaintainer mPrivateSpaceMaintainer;
private CharSequence[] mAutoLockRadioOptions;
private CharSequence[] mAutoLockRadioValues;
@Override
public void onCreate(@NonNull Bundle icicle) {
if (android.os.Flags.allowPrivateProfile()
&& android.multiuser.Flags.supportAutolockForPrivateSpace()) {
super.onCreate(icicle);
}
}
@Override
public void onStart() {
super.onStart();
if (mPrivateSpaceMaintainer.isPrivateSpaceLocked()) {
finish();
}
}
@Override
public void onAttach(@NonNull Context context) {
super.onAttach(context);
mPrivateSpaceMaintainer = PrivateSpaceMaintainer.getInstance(context);
mAutoLockRadioOptions =
context.getResources().getStringArray(R.array.private_space_auto_lock_options);
mAutoLockRadioValues =
context.getResources()
.getStringArray(R.array.private_space_auto_lock_options_values);
}
@Override
protected void addStaticPreferences(PreferenceScreen screen) {
final TopIntroPreference introPreference = new TopIntroPreference(screen.getContext());
introPreference.setTitle(R.string.private_space_auto_lock_page_summary);
screen.addPreference(introPreference);
}
@Override
public int getMetricsCategory() {
return SettingsEnums.PRIVATE_SPACE_SETTINGS;
}
@Override
protected int getPreferenceScreenResId() {
return R.xml.private_space_auto_lock_settings;
}
@Override
protected List<? extends CandidateInfo> getCandidates() {
final List<CandidateInfo> candidates = new ArrayList<>();
if (mAutoLockRadioValues != null) {
for (int i = 0; i < mAutoLockRadioValues.length; ++i) {
candidates.add(
new AutoLockCandidateInfo(
mAutoLockRadioOptions[i], mAutoLockRadioValues[i].toString()));
}
} else {
Log.e(TAG, "Autolock options do not exist.");
}
return candidates;
}
@Override
protected String getDefaultKey() {
return Integer.toString(mPrivateSpaceMaintainer.getPrivateSpaceAutoLockSetting());
}
@Override
protected boolean setDefaultKey(String key) {
try {
@Settings.Secure.PrivateSpaceAutoLockOption final int value = Integer.parseInt(key);
mPrivateSpaceMaintainer.setPrivateSpaceAutoLockSetting(value);
} catch (NumberFormatException e) {
Log.e(TAG, "could not persist screen timeout setting", e);
}
return true;
}
private static class AutoLockCandidateInfo extends CandidateInfo {
private final CharSequence mLabel;
private final String mKey;
AutoLockCandidateInfo(CharSequence label, String key) {
super(true);
mLabel = label;
mKey = key;
}
@NonNull
@Override
public CharSequence loadLabel() {
return mLabel;
}
@Nullable
@Override
public Drawable loadIcon() {
return null;
}
@NonNull
@Override
public String getKey() {
return mKey;
}
}
}