Slim recents [2/3]

@SKULSHADY: Cleanup, fixes and adapt for SettingsPreferenceFragment
@rohanpurohit: bringup to 10

Change-Id: I7fa5703534c9eb76a555db9a6d3349cc2b6a2b2d
Signed-off-by: rohan <purohit.rohan@gmail.com>

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

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;
+    }
+}

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;
+    }
+}

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<String, IconPackInfo> 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<String, IconPackInfo> 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<IconPackInfo> mSupportedPackages;
+        LayoutInflater mLayoutInflater;
+        String mCurrentIconPack;
+        int mCurrentIconPackPosition = -1;
+
+        IconAdapter(Context ctx, Map<String, IconPackInfo> supportedPackages) {
+            mLayoutInflater = LayoutInflater.from(ctx);
+            mSupportedPackages = new ArrayList<IconPackInfo>(supportedPackages.values());
+            Collections.sort(mSupportedPackages, new Comparator<IconPackInfo>() {
+                @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<String, IconPackInfo> getSupportedPackages(Context context) {
+        Intent i = new Intent();
+        Map<String, IconPackInfo> packages = new HashMap<String, IconPackInfo>();
+        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;
+    }
+}

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<String, Package> 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<String, Package>();
+        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<String,Package> 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<String,Package> 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<String,Package> 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<String,Package> map) {
+        String setting = Settings.System.SLIM_RECENTS_BLACKLIST_VALUES;
+
+        List<String> settings = new ArrayList<String>();
+        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);
+    }
+}