diff --git a/res/layout/dialog_iconpack.xml b/res/layout/dialog_iconpack.xml new file mode 100644 index 0000000..078f15d --- /dev/null +++ b/res/layout/dialog_iconpack.xml @@ -0,0 +1,29 @@ + + + + + diff --git a/res/layout/iconpack_view.xml b/res/layout/iconpack_view.xml new file mode 100644 index 0000000..ec99ed3 --- /dev/null +++ b/res/layout/iconpack_view.xml @@ -0,0 +1,39 @@ + + + + + + diff --git a/res/layout/iconpack_view_radio.xml b/res/layout/iconpack_view_radio.xml new file mode 100644 index 0000000..6a101f6 --- /dev/null +++ b/res/layout/iconpack_view_radio.xml @@ -0,0 +1,45 @@ + + + + + + + diff --git a/res/values/cherish_arrays.xml b/res/values/cherish_arrays.xml index 1d4c0e8..33dc3c3 100644 --- a/res/values/cherish_arrays.xml +++ b/res/values/cherish_arrays.xml @@ -40,7 +40,7 @@ 6 7 - + @string/lockscreen_clock_hide @@ -67,7 +67,7 @@ 9 10 - + @string/lockscreen_date_selection_default @@ -92,7 +92,7 @@ 7 8 - + @string/status_bar_clock_style_left @@ -155,7 +155,7 @@ EEEE MM/dd @string/clock_date_format_custom - + @string/clock_date_left @string/clock_date_right @@ -213,7 +213,7 @@ 2 3 - + @string/show_network_traffic_up @@ -226,7 +226,7 @@ 2 0 - + @string/volte_icon_asus @@ -245,7 +245,7 @@ 1 0 - + @string/lockscreen_charging_animation_off @@ -264,7 +264,7 @@ 4 5 - + @string/theme_type_light @@ -287,7 +287,7 @@ 7 8 - + @string/adaptive_playback_timeout_30_secs @@ -303,4 +303,27 @@ 300000 600000 + + + + @string/recent_panel_expanded_mode_auto + @string/recent_panel_expanded_mode_always + @string/recent_panel_expanded_mode_never + @string/recent_panel_expanded_mode_disabled + + + 0 + 1 + 2 + 3 + + + + @string/slim_recents_enter_exit_animation_translate + @string/slim_recents_enter_exit_animation_fade + + + 0 + 1 + diff --git a/res/values/cherish_strings.xml b/res/values/cherish_strings.xml index 1c84468..b70ceee 100644 --- a/res/values/cherish_strings.xml +++ b/res/values/cherish_strings.xml @@ -88,7 +88,7 @@ Show a brightness slider on bottom quick settings OneUI Show spacer above settings actionbar for easier use with one hand\nNOTE: restart settings app to see effect - + Clock style Select clock style @@ -102,7 +102,7 @@ Sammy (bold) Sammy (accent hour) Sammy (accent minute) - + Date style Date style @@ -116,12 +116,12 @@ Gradient Dark with accented borders Dark with gradient borders - + Status bar icons System icons Control which status bar icons are shown - + Statusbar items Clock @@ -180,7 +180,7 @@ Icon portrait (default) Circle (Dotted) Circle - Text + Text Hidden Big circle Circle (Filled) @@ -199,7 +199,7 @@ Enabled Enabled (inside icon) Enabled (estimate) - + Traffic indicators Customize network traffic indicators @@ -212,16 +212,16 @@ Net activity autohide threshold (KB/s) Hide arrows Hide the network traffic indicator arrows - + Icons 4G icon Display 4G icon in signal icon instead LTE - + VoLTE icon Display VoLTE icon (Needs a SystemUI restart to take effect) - + Select VoLTE Icon Default Icon @@ -230,7 +230,7 @@ HD Icon VoLTE Miui Icon VoLTE Asus Icon - + Display music visualizer Music visualizer @@ -253,11 +253,11 @@ Medium battery Almost full battery Full (100) battery - + Use old mobile type style Merge signal and type icons - + System theme Select theme @@ -269,7 +269,7 @@ Pitch black Dark Grey Material Ocean - + RGB Accent | Gradient Theming Themes @@ -278,7 +278,7 @@ Gradient Maker Gradient picker Gradient effect maker - + Secure power menu Secure power menu @@ -287,7 +287,7 @@ Power Menu Transparency Power/reboot menu opacity Power/reboot dialog dim background amount - + Rounded corners Adjust rounded corners and padding @@ -309,7 +309,7 @@ 2 minutes 5 minutes 10 minutes - + Label Carrier label @@ -332,4 +332,69 @@ Recognizing animation Show an animation while reading your fingerprint + + OK + Alternative recents + When using swipe up home navigation to open recents, only stock recents are supported + Slim Recents + Enable to use an alternative recents screen + Slim recents settings + Customize the additional settings for slim recents + Max allowed apps + Size + Expanded mode + Recent tasks expanded preview mode + Auto (Default) + Always + Never + Disabled + Panel background color + Card background color + Memory bar longpress gesture + Clear recents by long-pressing the memory bar + Icon Pack + Apply a custom icon pack for apps in the panel + No icon packs installed + Pick icon pack + Default icons + Card corner radius + + Show on the left edge + Show recent apps panel on the left edge of the screen + Blacklist + Apps blacklist + Apps to not show in the panel + Add app + Tap here to add, tap on added app to remove it + + + App Sidebar + Recents app sidebar + Show app shortcuts on the other edge + Sidebar shortcuts + Choose apps to show in the sidebar + Sidebar style + Change the look of the sidebar + Hide icon labels + Label color + Background color + Size + Open simultaneously with recents + Reduce recents opening lag by disabling this + Default (App based) + + + Default + Choose app + Delete + Remove selected item? + Memory Bar + Memory bar + Show a progress bar displaying RAM + Memory bar color + Memory bar text color + Animation + Translate + Fade + diff --git a/res/xml/cherish_settings_recents.xml b/res/xml/cherish_settings_recents.xml index 7784530..ad8cad2 100644 --- a/res/xml/cherish_settings_recents.xml +++ b/res/xml/cherish_settings_recents.xml @@ -18,4 +18,21 @@ android:title="@string/recents_title" xmlns:settings="http://schemas.android.com/apk/res/com.android.settings"> + + + + + + + + diff --git a/res/xml/slim_recent_app_sidebar.xml b/res/xml/slim_recent_app_sidebar.xml new file mode 100644 index 0000000..c0cb87c --- /dev/null +++ b/res/xml/slim_recent_app_sidebar.xml @@ -0,0 +1,23 @@ + + + + + + diff --git a/res/xml/slim_recent_app_sidebar_style.xml b/res/xml/slim_recent_app_sidebar_style.xml new file mode 100644 index 0000000..cd85f50 --- /dev/null +++ b/res/xml/slim_recent_app_sidebar_style.xml @@ -0,0 +1,58 @@ + + + + + + + + + + + + + + + + diff --git a/res/xml/slim_recents.xml b/res/xml/slim_recents.xml new file mode 100644 index 0000000..fb7344b --- /dev/null +++ b/res/xml/slim_recents.xml @@ -0,0 +1,150 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/res/xml/slim_recents_blacklist.xml b/res/xml/slim_recents_blacklist.xml new file mode 100644 index 0000000..f47bcd0 --- /dev/null +++ b/res/xml/slim_recents_blacklist.xml @@ -0,0 +1,27 @@ + + + + + + + + diff --git a/src/com/cherish/settings/fragments/RecentsSettings.java b/src/com/cherish/settings/fragments/RecentsSettings.java index 29284b4..0b8b9eb 100644 --- a/src/com/cherish/settings/fragments/RecentsSettings.java +++ b/src/com/cherish/settings/fragments/RecentsSettings.java @@ -11,6 +11,7 @@ import android.os.UserHandle; import androidx.preference.ListPreference; import androidx.preference.Preference; import androidx.preference.PreferenceScreen; +import androidx.preference.PreferenceCategory; import androidx.preference.Preference.OnPreferenceChangeListener; import androidx.preference.SwitchPreference; import android.provider.Settings; @@ -19,11 +20,20 @@ import com.android.settings.R; import java.util.Arrays; import java.util.HashSet; +import com.cherish.settings.preferences.SystemSettingMasterSwitchPreference; import com.android.settings.SettingsPreferenceFragment; public class RecentsSettings extends SettingsPreferenceFragment implements OnPreferenceChangeListener { + private static final String PREF_STOCK_RECENTS_CATEGORY = "stock_recents_category"; + private static final String PREF_ALTERNATIVE_RECENTS_CATEGORY = "alternative_recents_category"; + private static final String PREF_SWIPE_UP_ENABLED = "swipe_up_enabled_warning"; + + private PreferenceCategory mStockRecentsCategory; + private PreferenceCategory mAlternativeRecentsCategory; + private Context mContext; + @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); @@ -32,6 +42,75 @@ public class RecentsSettings extends SettingsPreferenceFragment implements ContentResolver resolver = getActivity().getContentResolver(); + mStockRecentsCategory = (PreferenceCategory) findPreference(PREF_STOCK_RECENTS_CATEGORY); + mAlternativeRecentsCategory = + (PreferenceCategory) findPreference(PREF_ALTERNATIVE_RECENTS_CATEGORY); + + // Alternative recents en-/disabling + Preference.OnPreferenceChangeListener alternativeRecentsChangeListener = + new Preference.OnPreferenceChangeListener() { + @Override + public boolean onPreferenceChange(Preference preference, Object newValue) { + updateDependencies(preference, (Boolean) newValue); + return true; + } + }; + for (int i = 0; i < mAlternativeRecentsCategory.getPreferenceCount(); i++) { + Preference preference = mAlternativeRecentsCategory.getPreference(i); + if (preference instanceof SystemSettingMasterSwitchPreference) { + preference.setOnPreferenceChangeListener(alternativeRecentsChangeListener); + } + } + + updateDependencies(); + + // Warning for alternative recents when gesture navigation is enabled, + // which directly controls quickstep (launcher) recents. + final int navigationMode = getActivity().getResources() + .getInteger(com.android.internal.R.integer.config_navBarInteractionMode); + // config_navBarInteractionMode: + // 0: 3 button mode (supports slim recents) + // 1: 2 button mode (currently does not support alternative recents) + // 2: gesture only (currently does not support alternative recents) + if (navigationMode != 0) { + for (int i = 0; i < mAlternativeRecentsCategory.getPreferenceCount(); i++) { + Preference preference = mAlternativeRecentsCategory.getPreference(i); + if (PREF_SWIPE_UP_ENABLED.equals(preference.getKey())) { + // We want to have that one enabled + continue; + } + preference.setEnabled(false); + } + } else { + mAlternativeRecentsCategory.removePreference(findPreference(PREF_SWIPE_UP_ENABLED)); + } + } + + private void updateDependencies() { + updateDependencies(null, null); + } + + private void updateDependencies(Preference updatedPreference, Boolean newValue) { + // Disable stock recents category if alternative enabled + boolean alternativeRecentsEnabled = newValue != null && newValue; + if (!alternativeRecentsEnabled) { + for (int i = 0; i < mAlternativeRecentsCategory.getPreferenceCount(); i++) { + Preference preference = mAlternativeRecentsCategory.getPreference(i); + if (preference == updatedPreference) { + // Already used newValue + continue; + } + if (preference instanceof SystemSettingMasterSwitchPreference + && ((SystemSettingMasterSwitchPreference) preference).isChecked()) { + alternativeRecentsEnabled = true; + break; + } + } + } + if (mStockRecentsCategory != null) { + mStockRecentsCategory.setEnabled(!alternativeRecentsEnabled); + } + } @Override diff --git a/src/com/cherish/settings/fragments/SlimRecentAppSidebar.java b/src/com/cherish/settings/fragments/SlimRecentAppSidebar.java new file mode 100644 index 0000000..850c394 --- /dev/null +++ b/src/com/cherish/settings/fragments/SlimRecentAppSidebar.java @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2018 Havoc-OS + * + * 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.cherish.settings.fragments; + +import android.os.Bundle; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsPreferenceFragment; + +import com.android.settings.R; + +public class SlimRecentAppSidebar extends SettingsPreferenceFragment { + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + addPreferencesFromResource(R.xml.slim_recent_app_sidebar); + } + + @Override + public int getMetricsCategory() { + return MetricsProto.MetricsEvent.CHERISH_SETTINGS; + } +} diff --git a/src/com/cherish/settings/fragments/SlimRecentAppSidebarStyle.java b/src/com/cherish/settings/fragments/SlimRecentAppSidebarStyle.java new file mode 100644 index 0000000..fd4029d --- /dev/null +++ b/src/com/cherish/settings/fragments/SlimRecentAppSidebarStyle.java @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2018 Havoc-OS + * + * 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.cherish.settings.fragments; + +import android.os.Bundle; +import android.os.UserHandle; +import android.provider.Settings; +import androidx.preference.Preference; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsPreferenceFragment; + +import com.android.settings.R; + +import net.margaritov.preference.colorpicker.ColorPickerPreference; + +public class SlimRecentAppSidebarStyle extends SettingsPreferenceFragment + implements Preference.OnPreferenceChangeListener { + + private static final String RECENT_APP_SIDEBAR_TEXT_COLOR = "recent_app_sidebar_text_color"; + private static final String RECENT_APP_SIDEBAR_BG_COLOR = "recent_app_sidebar_bg_color"; + + private ColorPickerPreference mRecentSidebarTextColor; + private ColorPickerPreference mRecentSidebarBgColor; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + addPreferencesFromResource(R.xml.slim_recent_app_sidebar_style); + + mRecentSidebarTextColor = (ColorPickerPreference) findPreference(RECENT_APP_SIDEBAR_TEXT_COLOR); + mRecentSidebarTextColor.setOnPreferenceChangeListener(this); + final int intColor = Settings.System.getInt(getContext().getContentResolver(), + Settings.System.RECENT_APP_SIDEBAR_TEXT_COLOR, 0xffffffff); + String hexColor = String.format("#%08x", (0xffffffff & intColor)); + if (hexColor.equals("#ffffffff")) { + mRecentSidebarTextColor.setSummary(R.string.default_string); + } else { + mRecentSidebarTextColor.setSummary(hexColor); + } + mRecentSidebarTextColor.setNewPreviewColor(intColor); + + mRecentSidebarBgColor = (ColorPickerPreference) findPreference(RECENT_APP_SIDEBAR_BG_COLOR); + mRecentSidebarBgColor.setOnPreferenceChangeListener(this); + final int intColorCard = Settings.System.getInt(getContext().getContentResolver(), + Settings.System.RECENT_APP_SIDEBAR_BG_COLOR, 0x00ffffff); + String hexColorCard = String.format("#%08x", (0x00ffffff & intColorCard)); + if (hexColorCard.equals("#00ffffff")) { + mRecentSidebarBgColor.setSummary(R.string.default_string); + } else { + mRecentSidebarBgColor.setSummary(hexColorCard); + } + mRecentSidebarBgColor.setNewPreviewColor(intColorCard); + } + + @Override + public boolean onPreferenceChange(Preference preference, Object newValue) { + if (preference == mRecentSidebarTextColor) { + String hex = ColorPickerPreference.convertToARGB( + Integer.valueOf(String.valueOf(newValue))); + if (hex.equals("#ffffffff")) { + preference.setSummary(R.string.default_string); + } else { + preference.setSummary(hex); + } + int intHex = ColorPickerPreference.convertToColorInt(hex); + Settings.System.putIntForUser(getContext().getContentResolver(), + Settings.System.RECENT_APP_SIDEBAR_TEXT_COLOR, + intHex, UserHandle.USER_CURRENT); + return true; + } else if (preference == mRecentSidebarBgColor) { + String hex = ColorPickerPreference.convertToARGB( + Integer.valueOf(String.valueOf(newValue))); + if (hex.equals("#00ffffff")) { + preference.setSummary(R.string.default_string); + } else { + preference.setSummary(hex); + } + int intHex = ColorPickerPreference.convertToColorInt(hex); + Settings.System.putIntForUser(getContext().getContentResolver(), + Settings.System.RECENT_APP_SIDEBAR_BG_COLOR, + intHex, UserHandle.USER_CURRENT); + return true; + } + return false; + } + + @Override + public int getMetricsCategory() { + return MetricsProto.MetricsEvent.CHERISH_SETTINGS; + } +} diff --git a/src/com/cherish/settings/fragments/SlimRecents.java b/src/com/cherish/settings/fragments/SlimRecents.java new file mode 100644 index 0000000..e795ab5 --- /dev/null +++ b/src/com/cherish/settings/fragments/SlimRecents.java @@ -0,0 +1,392 @@ +/* + * Copyright (C) 2017 AICP + * + * 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.cherish.settings.fragments; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.content.res.Resources; +import androidx.preference.Preference; +import androidx.preference.SwitchPreference; +import android.graphics.drawable.Drawable; +import android.os.Bundle; +import android.os.UserHandle; +import android.provider.Settings; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.AdapterView; +import android.widget.BaseAdapter; +import android.widget.ImageView; +import android.widget.ListView; +import android.widget.RadioButton; +import android.widget.TextView; +import android.widget.Toast; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsPreferenceFragment; +import com.android.settings.R; + +import net.margaritov.preference.colorpicker.ColorPickerPreference; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.Map; + +public class SlimRecents extends SettingsPreferenceFragment + implements Preference.OnPreferenceChangeListener, DialogInterface.OnDismissListener { + + private static final String RECENT_PANEL_LEFTY_MODE = "recent_panel_lefty_mode"; + private static final String RECENT_ICON_PACK = "slim_icon_pack"; + private static final String RECENT_PANEL_BG_COLOR = "recent_panel_bg_color"; + private static final String RECENT_CARD_BG_COLOR = "recent_card_bg_color"; + private static final String SLIM_MEM_BAR_COLOR = "slim_mem_bar_color"; + private static final String SLIM_MEM_TEXT_COLOR = "slim_mem_text_color"; + + private SwitchPreference mRecentPanelLeftyMode; + private Preference mIconPack; + private ColorPickerPreference mRecentPanelBgColor; + private ColorPickerPreference mRecentCardBgColor; + private ColorPickerPreference mMemBarColor; + private ColorPickerPreference mMemTextColor; + + // Icon pack + private final static String[] sSupportedActions = new String[] { + "org.adw.launcher.THEMES", + "com.gau.go.launcherex.theme" + }; + private static final String[] sSupportedCategories = new String[] { + "com.fede.launcher.THEME_ICONPACK", + "com.anddoes.launcher.THEME", + "com.teslacoilsw.launcher.THEME" + }; + private AlertDialog mDialog; + private ListView mListView; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + addPreferencesFromResource(R.xml.slim_recents); + + mRecentPanelLeftyMode = (SwitchPreference) findPreference(RECENT_PANEL_LEFTY_MODE); + mRecentPanelLeftyMode.setOnPreferenceChangeListener(this); + mIconPack = findPreference(RECENT_ICON_PACK); + + // Recent panel background color + mRecentPanelBgColor = (ColorPickerPreference) findPreference(RECENT_PANEL_BG_COLOR); + mRecentPanelBgColor.setOnPreferenceChangeListener(this); + final int intColor = Settings.System.getInt(getContext().getContentResolver(), + Settings.System.RECENT_PANEL_BG_COLOR, 0x00ffffff); + String hexColor = String.format("#%08x", (0x00ffffff & intColor)); + if (hexColor.equals("#00ffffff")) { + mRecentPanelBgColor.setSummary(R.string.default_string); + } else { + mRecentPanelBgColor.setSummary(hexColor); + } + mRecentPanelBgColor.setNewPreviewColor(intColor); + + // Recent card background color + mRecentCardBgColor = (ColorPickerPreference) findPreference(RECENT_CARD_BG_COLOR); + mRecentCardBgColor.setOnPreferenceChangeListener(this); + final int intColorCard = Settings.System.getInt(getContext().getContentResolver(), + Settings.System.RECENT_CARD_BG_COLOR, 0x00ffffff); + String hexColorCard = String.format("#%08x", (0x00ffffff & intColorCard)); + if (hexColorCard.equals("#00ffffff")) { + mRecentCardBgColor.setSummary(R.string.default_auto_string); + } else { + mRecentCardBgColor.setSummary(hexColorCard); + } + mRecentCardBgColor.setNewPreviewColor(intColorCard); + + mMemBarColor = (ColorPickerPreference) findPreference(SLIM_MEM_BAR_COLOR); + mMemBarColor.setOnPreferenceChangeListener(this); + final int intMemColor = Settings.System.getInt(getContext().getContentResolver(), + Settings.System.SLIM_MEM_BAR_COLOR, 0xffffffff); + String hexMemColor = String.format("#%08x", (0xffffffff & intMemColor)); + if (hexMemColor.equals("#ffffffff")) { + mMemBarColor.setSummary(R.string.default_string); + } else { + mMemBarColor.setSummary(hexMemColor); + } + mMemBarColor.setNewPreviewColor(intMemColor); + + mMemTextColor = (ColorPickerPreference) findPreference(SLIM_MEM_TEXT_COLOR); + mMemTextColor.setOnPreferenceChangeListener(this); + final int intTextColor = Settings.System.getInt(getContext().getContentResolver(), + Settings.System.SLIM_MEM_TEXT_COLOR, 0xffffffff); + String hexTextColor = String.format("#%08x", (0xffffffff & intTextColor)); + if (hexTextColor.equals("#ffffffff")) { + mMemTextColor.setSummary(R.string.default_string); + } else { + mMemTextColor.setSummary(hexTextColor); + } + mMemTextColor.setNewPreviewColor(intTextColor); + } + + @Override + public void onResume() { + super.onResume(); + + boolean recentLeftyMode = Settings.System.getInt(getContext().getContentResolver(), + Settings.System.RECENT_PANEL_GRAVITY, Gravity.END) == Gravity.START; + mRecentPanelLeftyMode.setChecked(recentLeftyMode); + } + + @Override + public boolean onPreferenceChange(Preference preference, Object newValue) { + if (preference == mRecentPanelLeftyMode) { + Settings.System.putInt(getContext().getContentResolver(), + Settings.System.RECENT_PANEL_GRAVITY, + ((Boolean) newValue) ? Gravity.START : Gravity.END); + return true; + } else if (preference == mRecentPanelBgColor) { + String hex = ColorPickerPreference.convertToARGB( + Integer.valueOf(String.valueOf(newValue))); + if (hex.equals("#00ffffff")) { + preference.setSummary(R.string.default_string); + } else { + preference.setSummary(hex); + } + int intHex = ColorPickerPreference.convertToColorInt(hex); + Settings.System.putIntForUser(getContext().getContentResolver(), + Settings.System.RECENT_PANEL_BG_COLOR, + intHex, UserHandle.USER_CURRENT); + return true; + } else if (preference == mRecentCardBgColor) { + String hex = ColorPickerPreference.convertToARGB( + Integer.valueOf(String.valueOf(newValue))); + if (hex.equals("#00ffffff")) { + preference.setSummary(R.string.default_auto_string); + } else { + preference.setSummary(hex); + } + int intHex = ColorPickerPreference.convertToColorInt(hex); + Settings.System.putIntForUser(getContext().getContentResolver(), + Settings.System.RECENT_CARD_BG_COLOR, + intHex, UserHandle.USER_CURRENT); + return true; + } else if (preference == mMemBarColor) { + String hex = ColorPickerPreference.convertToARGB( + Integer.valueOf(String.valueOf(newValue))); + if (hex.equals("#ffffffff")) { + preference.setSummary(R.string.default_string); + } else { + preference.setSummary(hex); + } + int intHex = ColorPickerPreference.convertToColorInt(hex); + Settings.System.putIntForUser(getContext().getContentResolver(), + Settings.System.SLIM_MEM_BAR_COLOR, + intHex, UserHandle.USER_CURRENT); + return true; + } else if (preference == mMemTextColor) { + String hex = ColorPickerPreference.convertToARGB( + Integer.valueOf(String.valueOf(newValue))); + if (hex.equals("#ffffffff")) { + preference.setSummary(R.string.default_string); + } else { + preference.setSummary(hex); + } + int intHex = ColorPickerPreference.convertToColorInt(hex); + Settings.System.putIntForUser(getContext().getContentResolver(), + Settings.System.SLIM_MEM_TEXT_COLOR, + intHex, UserHandle.USER_CURRENT); + return true; + } + return false; + } + + @Override + public boolean onPreferenceTreeClick(Preference preference) { + if (preference == mIconPack) { + pickIconPack(getContext()); + return true; + } else { + return super.onPreferenceTreeClick(preference); + } + } + + /** Slim Recents Icon Pack Dialog **/ + private void pickIconPack(final Context context) { + if (mDialog != null) { + return; + } + Map supportedPackages = getSupportedPackages(context); + if (supportedPackages.isEmpty()) { + Toast.makeText(context, R.string.no_iconpacks_summary, Toast.LENGTH_SHORT).show(); + return; + } + AlertDialog.Builder builder = new AlertDialog.Builder(context) + .setTitle(R.string.dialog_pick_iconpack_title) + .setOnDismissListener(this) + .setNegativeButton(R.string.cancel, null) + .setView(createDialogView(context, supportedPackages)); + mDialog = builder.show(); + } + + private View createDialogView(final Context context, Map supportedPackages) { + final LayoutInflater inflater = (LayoutInflater) context + .getSystemService(Context.LAYOUT_INFLATER_SERVICE); + final View view = inflater.inflate(R.layout.dialog_iconpack, null); + final IconAdapter adapter = new IconAdapter(context, supportedPackages); + + mListView = (ListView) view.findViewById(R.id.iconpack_list); + mListView.setAdapter(adapter); + mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() { + @Override + public void onItemClick(AdapterView parent, View view, + int position, long id) { + if (adapter.isCurrentIconPack(position)) { + return; + } + String selectedPackage = adapter.getItem(position); + Settings.System.putString(getContext().getContentResolver(), + Settings.System.SLIM_RECENTS_ICON_PACK, selectedPackage); + mDialog.dismiss(); + } + }); + + return view; + } + + @Override + public void onDismiss(DialogInterface dialog) { + if (mDialog != null) { + mDialog = null; + } + } + + private static class IconAdapter extends BaseAdapter { + ArrayList mSupportedPackages; + LayoutInflater mLayoutInflater; + String mCurrentIconPack; + int mCurrentIconPackPosition = -1; + + IconAdapter(Context ctx, Map supportedPackages) { + mLayoutInflater = LayoutInflater.from(ctx); + mSupportedPackages = new ArrayList(supportedPackages.values()); + Collections.sort(mSupportedPackages, new Comparator() { + @Override + public int compare(IconPackInfo lhs, IconPackInfo rhs) { + return lhs.label.toString().compareToIgnoreCase(rhs.label.toString()); + } + }); + + Resources res = ctx.getResources(); + String defaultLabel = res.getString(R.string.default_iconpack_title); + Drawable icon = res.getDrawable(android.R.drawable.sym_def_app_icon); + mSupportedPackages.add(0, new IconPackInfo(defaultLabel, icon, "")); + mCurrentIconPack = Settings.System.getString(ctx.getContentResolver(), + Settings.System.SLIM_RECENTS_ICON_PACK); + } + + @Override + public int getCount() { + return mSupportedPackages.size(); + } + + @Override + public String getItem(int position) { + return (String) mSupportedPackages.get(position).packageName; + } + + @Override + public long getItemId(int position) { + return 0; + } + + public boolean isCurrentIconPack(int position) { + return mCurrentIconPackPosition == position; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + if (convertView == null) { + convertView = mLayoutInflater.inflate(R.layout.iconpack_view_radio, null); + } + IconPackInfo info = mSupportedPackages.get(position); + TextView txtView = (TextView) convertView.findViewById(R.id.title); + txtView.setText(info.label); + ImageView imgView = (ImageView) convertView.findViewById(R.id.icon); + imgView.setImageDrawable(info.icon); + RadioButton radioButton = (RadioButton) convertView.findViewById(R.id.radio); + boolean isCurrentIconPack = info.packageName.equals(mCurrentIconPack); + radioButton.setChecked(isCurrentIconPack); + if (isCurrentIconPack) { + mCurrentIconPackPosition = position; + } + return convertView; + } + } + + private Map getSupportedPackages(Context context) { + Intent i = new Intent(); + Map packages = new HashMap(); + PackageManager packageManager = context.getPackageManager(); + for (String action : sSupportedActions) { + i.setAction(action); + for (ResolveInfo r : packageManager.queryIntentActivities(i, 0)) { + IconPackInfo info = new IconPackInfo(r, packageManager); + packages.put(r.activityInfo.packageName, info); + } + } + i = new Intent(Intent.ACTION_MAIN); + for (String category : sSupportedCategories) { + i.addCategory(category); + for (ResolveInfo r : packageManager.queryIntentActivities(i, 0)) { + IconPackInfo info = new IconPackInfo(r, packageManager); + packages.put(r.activityInfo.packageName, info); + } + i.removeCategory(category); + } + return packages; + } + + private static class IconPackInfo { + String packageName; + CharSequence label; + Drawable icon; + + IconPackInfo(ResolveInfo r, PackageManager packageManager) { + packageName = r.activityInfo.packageName; + icon = r.loadIcon(packageManager); + label = r.loadLabel(packageManager); + } + + IconPackInfo(){ + } + + public IconPackInfo(String label, Drawable icon, String packageName) { + this.label = label; + this.icon = icon; + this.packageName = packageName; + } + } + + @Override + public int getMetricsCategory() { + return MetricsProto.MetricsEvent.CHERISH_SETTINGS; + } +} diff --git a/src/com/cherish/settings/fragments/SlimRecentsBlacklist.java b/src/com/cherish/settings/fragments/SlimRecentsBlacklist.java new file mode 100644 index 0000000..4b75820 --- /dev/null +++ b/src/com/cherish/settings/fragments/SlimRecentsBlacklist.java @@ -0,0 +1,294 @@ +/* + * Copyright (C) 2017 The ABC rom + * Copyright (C) 2017 AICP + * + * 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.cherish.settings.fragments; + +import android.app.AlertDialog; +import android.app.Dialog; +import android.content.ContentResolver; +import android.content.Context; +import android.content.DialogInterface; +import android.content.DialogInterface.OnClickListener; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; +import android.os.Bundle; +import androidx.preference.Preference; +import androidx.preference.PreferenceGroup; +import androidx.preference.PreferenceScreen; +import android.provider.Settings; +import android.text.TextUtils; +import android.view.View; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemClickListener; +import android.widget.RadioButton; +import android.widget.ListView; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsPreferenceFragment; +import com.android.settings.R; +import com.cherish.settings.preferences.PackageListAdapter; +import com.cherish.settings.preferences.PackageListAdapter.PackageItem; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.Map; +import java.util.List; + +public class SlimRecentsBlacklist extends SettingsPreferenceFragment implements + Preference.OnPreferenceClickListener { + + private static final String TAG = "SlimRecentsBlacklist"; + + private static final int DIALOG_BLACKLIST_APPS = 1; + + private PackageListAdapter mPackageAdapter; + private PackageManager mPackageManager; + private PreferenceGroup mBlacklistPrefList; + private Preference mAddBlacklistPref; + private String mBlacklistPackageList; + private Map mBlacklistPackages; + + private AlertDialog mDialog; + private ListView mListView; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + addPreferencesFromResource(R.xml.slim_recents_blacklist); + + initializeAllPreferences(); + } + + @Override + public Dialog onCreateDialog(int dialogId) { + switch (dialogId) { + case DIALOG_BLACKLIST_APPS: { + Dialog dialog; + AlertDialog.Builder alertDialog = new AlertDialog.Builder(getActivity()); + final ListView list = new ListView(getActivity()); + list.setAdapter(mPackageAdapter); + alertDialog.setTitle(R.string.profile_choose_app); + alertDialog.setView(list); + dialog = alertDialog.create(); + list.setOnItemClickListener(new OnItemClickListener() { + @Override + public void onItemClick(AdapterView parent, View view, int position, long id) { + // Add empty application definition, the user will be able to edit it later + PackageItem info = (PackageItem) parent.getItemAtPosition(position); + addCustomApplicationPref(info.packageName, mBlacklistPackages); + dialog.cancel(); + } + }); + return dialog; + } + } + return super.onCreateDialog(dialogId); + } + + @Override + public int getDialogMetricsCategory(int dialogId) { + switch (dialogId) { + case DIALOG_BLACKLIST_APPS: + return MetricsProto.MetricsEvent.CHERISH_SETTINGS; + default: + return 0; + } + } + + @Override + public int getMetricsCategory() { + return MetricsProto.MetricsEvent.CHERISH_SETTINGS; + } + + @Override + public void onResume() { + super.onResume(); + refreshCustomApplicationPrefs(); + } + + private void initializeAllPreferences() { + mPackageManager = getActivity().getPackageManager(); + mPackageAdapter = new PackageListAdapter(getActivity()); + //mBlacklistPrefList = (PreferenceGroup) findPreference("blacklist_applications"); + mBlacklistPrefList = getPreferenceScreen(); + mBlacklistPrefList.setOrderingAsAdded(false); + mBlacklistPackages = new HashMap(); + mAddBlacklistPref = findPreference("add_blacklist_packages"); + mAddBlacklistPref.setOnPreferenceClickListener(this); + } + + @Override + public boolean onPreferenceClick(Preference preference) { + if (preference == mAddBlacklistPref) { + showDialog(DIALOG_BLACKLIST_APPS); + } else { + AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()) + .setTitle(R.string.dialog_delete_title) + .setMessage(R.string.dialog_delete_message) + //.setIconAttribute(android.R.attr.alertDialogIcon) + .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + removeApplicationPref(preference.getKey(), mBlacklistPackages); + } + }) + .setNegativeButton(android.R.string.cancel, null); + + builder.show(); + } + return true; + } + + /** + * Application class + */ + private static class Package { + public String name; + /** + * Stores all the application values in one call + * @param name + */ + public Package(String name) { + this.name = name; + } + + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append(name); + return builder.toString(); + } + + public static Package fromString(String value) { + if (TextUtils.isEmpty(value)) { + return null; + } + + try { + Package item = new Package(value); + return item; + } catch (NumberFormatException e) { + return null; + } + } + + }; + + private void refreshCustomApplicationPrefs() { + if (!parsePackageList()) { + return; + } + + // Add the Application Preferences + if (mBlacklistPrefList != null) { + mBlacklistPrefList.removeAll(); + + for (Package pkg : mBlacklistPackages.values()) { + try { + Preference pref = createPreferenceFromInfo(pkg); + mBlacklistPrefList.addPreference(pref); + } catch (PackageManager.NameNotFoundException e) { + // Do nothing + } + } + } + + // Keep these at the top + mAddBlacklistPref.setOrder(0); + // Add 'add' options + mBlacklistPrefList.addPreference(mAddBlacklistPref); + } + + private void addCustomApplicationPref(String packageName, Map map) { + Package pkg = map.get(packageName); + if (pkg == null) { + pkg = new Package(packageName); + map.put(packageName, pkg); + savePackageList(false, map); + refreshCustomApplicationPrefs(); + } + } + + private Preference createPreferenceFromInfo(Package pkg) + throws PackageManager.NameNotFoundException { + PackageInfo info = mPackageManager.getPackageInfo(pkg.name, + PackageManager.GET_META_DATA); + Preference pref = + new Preference(getActivity()); + + pref.setKey(pkg.name); + pref.setTitle(info.applicationInfo.loadLabel(mPackageManager)); + pref.setIcon(info.applicationInfo.loadIcon(mPackageManager)); + pref.setPersistent(false); + pref.setOnPreferenceClickListener(this); + return pref; + } + + private void removeApplicationPref(String packageName, Map map) { + if (map.remove(packageName) != null) { + savePackageList(false, map); + refreshCustomApplicationPrefs(); + } + } + + private boolean parsePackageList() { + boolean parsed = false; + final String blacklistString = Settings.System.getString(getActivity().getContentResolver(), + Settings.System.SLIM_RECENTS_BLACKLIST_VALUES); + + if (!TextUtils.equals(mBlacklistPackageList, blacklistString)) { + mBlacklistPackageList = blacklistString; + mBlacklistPackages.clear(); + parseAndAddToMap(blacklistString, mBlacklistPackages); + parsed = true; + } + + return parsed; + } + + private void parseAndAddToMap(String baseString, Map map) { + if (baseString == null) { + return; + } + + final String[] array = TextUtils.split(baseString, "\\|"); + for (String item : array) { + if (TextUtils.isEmpty(item)) { + continue; + } + Package pkg = Package.fromString(item); + map.put(pkg.name, pkg); + } + } + + private void savePackageList(boolean preferencesUpdated, Map map) { + String setting = Settings.System.SLIM_RECENTS_BLACKLIST_VALUES; + + List settings = new ArrayList(); + for (Package app : map.values()) { + settings.add(app.toString()); + } + final String value = TextUtils.join("|", settings); + if (preferencesUpdated) { + mBlacklistPackageList = value; + } + Settings.System.putString(getActivity().getContentResolver(), + setting, value); + } +}