@Override
@SuppressLint("RestrictedApi")
protected RecyclerView.Adapter onCreateAdapter(PreferenceScreen preferenceScreen) {
  return new PreferenceGroupAdapter(preferenceScreen) {
    @Override
    public void onBindViewHolder(PreferenceViewHolder holder, int position) {
      super.onBindViewHolder(holder, position);
      Preference preference = getItem(position);
      if (preference instanceof PreferenceCategory) {
        setZeroPaddingToLayoutChildren(holder.itemView);
      } else {
        View iconFrame = holder.itemView.findViewById(R.id.icon_frame);
        if (iconFrame != null) {
          iconFrame.setVisibility(preference.getIcon() == null ? View.GONE : View.VISIBLE);
        }
      }
    }
  };
}
 

@Override
public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {

    // Add movie preferences, defined in the XML file in res->xml->pref_movie
    addPreferencesFromResource(R.xml.pref_movie);

    // Get shared preferences
    SharedPreferences sharedPreferences = getPreferenceScreen().getSharedPreferences();
    // Get the preference screen
    PreferenceScreen prefScreen = getPreferenceScreen();
    // Get the number of preferences
    int count = prefScreen.getPreferenceCount();

    // Go through all of the preferences, and set up their preference summary.
    for (int i = 0; i < count; i++) {
        Preference p = prefScreen.getPreference(i);

        String value = sharedPreferences.getString(p.getKey(), DEFAULT_VALUE);
        setPreferenceSummary(p, value);
    }
}
 

private void advancedPurchased(SharedPreferences sharedPreferences, PreferenceScreen preferenceScreen){
    advancedOptionsPurchased = true;
    sharedPreferences.edit().putBoolean(ADVANCED_PURCHASED_KEY, true).apply();
    preferenceScreen.findPreference(ADS_ENABLED_KEY).setEnabled(false);
    preferenceScreen.findPreference(ADS_ENABLED_KEY).setSummary(getResources().getString(R.string.settingsAdsDisabledSummary));
    preferenceScreen.findPreference("pref_advanced_options").setEnabled(true);
    sharedPreferences.edit().putBoolean(ADS_ENABLED_KEY, false).apply();
    preferenceScreen.findPreference(CUSTOM_NOTIFICATIONS_KEY).setEnabled(true);
    preferenceScreen.findPreference(SMART_NOTIFICATIONS_KEY).setEnabled(true);
    preferenceScreen.findPreference("pref_advanced_purchase").setSummary(getString(R.string.settingsAdvancedPurchasedSummary));
    if (sharedPreferences.getBoolean(SMART_NOTIFICATIONS_KEY, false)){
        preferenceScreen.findPreference(NOTIF_AMOUNT_KEY).setEnabled(false);
    }
    if (sharedPreferences.getBoolean(DND_KEY, false)) {
        preferenceScreen.findPreference(DND_DELAY_KEY).setEnabled(true);
    }
}
 

@Override
protected RecyclerView.Adapter onCreateAdapter(PreferenceScreen preferenceScreen) {
    return new PreferenceGroupAdapter(preferenceScreen) {
        @SuppressLint("RestrictedApi")
        @Override
        public void onBindViewHolder(PreferenceViewHolder holder, int position) {
            super.onBindViewHolder(holder, position);
            Preference preference = getItem(position);
            if (preference instanceof PreferenceCategory)
                setZeroPaddingToLayoutChildren(holder.itemView);
            else {
                View iconFrame = holder.itemView.findViewById(R.id.icon_frame);
                if (iconFrame != null) {
                    iconFrame.setVisibility(preference.getIcon() == null ? View.GONE : View.VISIBLE);
                }
            }
        }
    };
}
 

@Override
public boolean onPreferenceStartScreen(androidx.preference.PreferenceFragmentCompat caller, PreferenceScreen pref) {
    final String TAG = "onPreferenceStartScreen";
    SettingsFragment fragment = new SettingsFragment();
    Bundle args = new Bundle();
    args.putString(PreferenceFragmentCompat.ARG_PREFERENCE_ROOT, pref.getKey());
    fragment.setArguments(args);

    FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
    ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
    ft.replace(R.id.fragment, fragment, pref.getKey());
    ft.addToBackStack(pref.getKey());
    ft.commitAllowingStateLoss();

    Log.d(TAG, pref + "");
    return true;
}
 

@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    EnabledApplicationsViewModel viewModel = ViewModelProviders.of(getActivity()).get(EnabledApplicationsViewModel.class);
    viewModel.getFilteredCheckBoxPrefsData().observe(getViewLifecycleOwner(), checkBoxPreferencesData -> {
        setPreferencesFromResource(R.xml.enabled_applications_preferences, null);
        PreferenceScreen prefScreen = (PreferenceScreen) findPreference(getString(R.string.enabled_apps_pref_screen));
        for (CheckBoxPreferenceData checkBoxPreferenceData : checkBoxPreferencesData) {
            CheckBoxPreference c = new CheckBoxPreference(getPreferenceScreen().getContext());
            c.setKey(checkBoxPreferenceData.key);
            c.setTitle(checkBoxPreferenceData.title);
            c.setSummary(checkBoxPreferenceData.summary);
            c.setIcon(checkBoxPreferenceData.icon);
            prefScreen.addPreference(c);
        }
    });
}
 

@Override
public void onSharedPreferenceChanged(SharedPreferences sp, String key) {
    boolean newSettingsValue = sp.getBoolean(key, false);
    String prefEnableDisableAllKey = getString(R.string.preference_enable_disable_all_applications);
    if (key.equals(prefEnableDisableAllKey)) {
        final PreferenceScreen prefScreen = findPreference(getString(R.string.enabled_apps_pref_screen));
        for (int i = 1; i < prefScreen.getPreferenceCount(); i++) {
            ((CheckBoxPreference) (prefScreen.getPreference(i))).setChecked(newSettingsValue);
        }
    }

    // If newSettingsValue == false, clear it from SharedPreferences file to save up some space.
    // Since AN2Linux will default to false if the setting is not found.
    if (!newSettingsValue) {
        sp.edit().remove(key).apply();
    }
}
 

@Override
@SuppressLint("RestrictedApi")
protected RecyclerView.Adapter onCreateAdapter(PreferenceScreen preferenceScreen) {
    return new PreferenceGroupAdapter(preferenceScreen) {
        @Override
        public void onBindViewHolder(@NonNull PreferenceViewHolder holder, int position) {
            super.onBindViewHolder(holder, position);
            Preference preference = getItem(position);
            if (preference instanceof PreferenceCategory)
                setZeroPaddingToLayoutChildren(holder.itemView);
            else {
                View iconFrame = holder.itemView.findViewById(R.id.icon_frame);
                if (iconFrame != null) {
                    iconFrame.setVisibility(preference.getIcon() == null ? View.GONE : View.VISIBLE);
                }
            }
        }
    };
}
 

@Override
protected RecyclerView.Adapter onCreateAdapter(PreferenceScreen preferenceScreen) {
    return new PreferenceGroupAdapter(preferenceScreen) {
        @SuppressLint("RestrictedApi")
        @Override
        public void onBindViewHolder(PreferenceViewHolder holder, int position) {
            super.onBindViewHolder(holder, position);
            Preference preference = getItem(position);
            if (preference instanceof PreferenceCategory)
                setZeroPaddingToLayoutChildren(holder.itemView);
            else {
                View iconFrame = holder.itemView.findViewById(R.id.icon_frame);
                if (iconFrame != null) {
                    iconFrame.setVisibility(preference.getIcon() == null ? View.GONE : View.VISIBLE);
                }
            }
        }
    };
}
 

@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    EnabledApplicationsViewModel viewModel = ViewModelProviders.of(getActivity()).get(EnabledApplicationsViewModel.class);
    viewModel.getFilteredCheckBoxPrefsData().observe(getViewLifecycleOwner(), checkBoxPreferencesData -> {
        setPreferencesFromResource(R.xml.enabled_applications_preferences, null);
        PreferenceScreen prefScreen = (PreferenceScreen) findPreference(getString(R.string.enabled_apps_pref_screen));
        for (CheckBoxPreferenceData checkBoxPreferenceData : checkBoxPreferencesData) {
            CheckBoxPreference c = new CheckBoxPreference(getPreferenceScreen().getContext());
            c.setKey(checkBoxPreferenceData.key);
            c.setTitle(checkBoxPreferenceData.title);
            c.setSummary(checkBoxPreferenceData.summary);
            c.setIcon(checkBoxPreferenceData.icon);
            prefScreen.addPreference(c);
        }
    });
}
 

@Override
public void onSharedPreferenceChanged(SharedPreferences sp, String key) {
    boolean newSettingsValue = sp.getBoolean(key, false);
    String prefEnableDisableAllKey = getString(R.string.preference_enable_disable_all_applications);
    if (key.equals(prefEnableDisableAllKey)) {
        final PreferenceScreen prefScreen = findPreference(getString(R.string.enabled_apps_pref_screen));
        for (int i = 1; i < prefScreen.getPreferenceCount(); i++) {
            ((CheckBoxPreference) (prefScreen.getPreference(i))).setChecked(newSettingsValue);
        }
    }

    // If newSettingsValue == false, clear it from SharedPreferences file to save up some space.
    // Since AN2Linux will default to false if the setting is not found.
    if (!newSettingsValue) {
        sp.edit().remove(key).apply();
    }
}
 

@Override protected RecyclerView.Adapter onCreateAdapter(PreferenceScreen preferenceScreen) {
  return new PreferenceGroupAdapter(preferenceScreen) {
    @SuppressLint("RestrictedApi") @Override public void onBindViewHolder(PreferenceViewHolder holder, int position) {
      super.onBindViewHolder(holder, position);
      Preference preference = getItem(position);
      if (preference instanceof PreferenceCategory) {
        setZeroPaddingToLayoutChildren(holder.itemView);
      } else {
        View iconFrame = holder.itemView.findViewById(R.id.icon_frame);
        if (iconFrame != null) {
          iconFrame.setVisibility(preference.getIcon() == null ? View.GONE : View.VISIBLE);
        }
      }
    }
  };
}
 

@Override
public boolean onPreferenceStartScreen(PreferenceFragmentCompat caller, PreferenceScreen preferenceScreen) {
    try {
        FragmentTransaction ft = getActivity().getSupportFragmentManager().beginTransaction();
        SettingsFragment fragment = new SettingsFragment();
        Bundle args = new Bundle();
        args.putString(PreferenceFragmentCompat.ARG_PREFERENCE_ROOT, preferenceScreen.getKey());
        fragment.setArguments(args);
        ft.add(R.id.settings_container, fragment, preferenceScreen.getKey());
        ft.addToBackStack(preferenceScreen.getKey());
        ft.commit();
    } catch(Exception e){
        e.printStackTrace();
        throw e;
    }
    return true;
}
 

private void updateNumberOfPacketsSummary() {
	final PreferenceScreen screen = getPreferenceScreen();
	final SharedPreferences preferences = getPreferenceManager().getSharedPreferences();

       String value = preferences.getString(SETTINGS_NUMBER_OF_PACKETS, String.valueOf(SETTINGS_NUMBER_OF_PACKETS_DEFAULT));
       // Security check
       if (TextUtils.isEmpty(value)) {
           value = String.valueOf(SETTINGS_NUMBER_OF_PACKETS_DEFAULT);
           preferences.edit().putString(SETTINGS_NUMBER_OF_PACKETS, value).apply();
       }
       screen.findPreference(SETTINGS_NUMBER_OF_PACKETS).setSummary(value);

	final int valueInt = Integer.parseInt(value);
	if (valueInt > 200 && Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
		new AlertDialog.Builder(requireContext()).setMessage(R.string.dfu_settings_dfu_number_of_packets_info).setTitle(R.string.dfu_settings_dfu_information)
				.setPositiveButton(R.string.ok, null)
				.show();
	}
}
 

@RequiresApi(api = Util.R_VERSION_CODE)
@Override
public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
    PreferenceScreen preferenceScreen = getPreferenceManager().createPreferenceScreen(
            getPreferenceManager().getContext());
    setPreferenceScreen(preferenceScreen);

    final Context preferenceContext = getPreferenceManager().getContext();
    for (UserRestriction restriction : UserRestriction.PROFILE_OWNER_ORG_DEVICE_RESTRICTIONS) {
        DpcSwitchPreference preference = new DpcSwitchPreference(preferenceContext);
        preference.setTitle(restriction.titleResId);
        preference.setKey(restriction.key);
        preference.setOnPreferenceChangeListener(this);
        preferenceScreen.addPreference(preference);
    }

    updateAllUserRestrictions();
    constrainPreferences();
}
 

@Override
public void onCreatePreferences(Bundle bundle, String rootkey) {
    PreferenceScreen preferenceScreen = getPreferenceManager().createPreferenceScreen(
            getPreferenceManager().getContext());
    setPreferenceScreen(preferenceScreen);

    final Context preferenceContext = getPreferenceManager().getContext();
    for (UserRestriction restriction : UserRestriction.ALL_USER_RESTRICTIONS) {
        DpcSwitchPreference preference = new DpcSwitchPreference(preferenceContext);
        preference.setTitle(restriction.titleResId);
        preference.setKey(restriction.key);
        preference.setOnPreferenceChangeListener(this);
        preferenceScreen.addPreference(preference);
    }

    updateAllUserRestrictions();
    constrainPreferences();
}
 

private void setupLocalizedText() {
    Map<String, String> prefToTitleMap = getPrefKeyTitleMap();
    if (prefToTitleMap != null) {
        PreferenceScreen screen = getPreferenceScreen();
        for (int i = 0; i < screen.getPreferenceCount(); i++) {
            String key = screen.getPreference(i).getKey();
            if (prefToTitleMap.containsKey(key)) {
                try {
                    String localizedString = Localization.get(prefToTitleMap.get(key));
                    screen.getPreference(i).setTitle(localizedString);
                } catch (NoLocalizedTextException nle) {
                    Log.w(TAG, "Unable to localize: " + prefToTitleMap.get(key));
                }
            }
        }
    }
}
 

private void hideOrShowDangerousSettings() {
    Preference[] onScreenPrefs = getOnScreenPrefs();
    if (!GlobalPrivilegesManager.isAdvancedSettingsAccessEnabled() && !BuildConfig.DEBUG) {
        // Dangerous privileges should not be showing
        PreferenceScreen prefScreen = getPreferenceScreen();
        for (Preference p : onScreenPrefs) {
            if (p != null && !WHITELISTED_DEVELOPER_PREF_KEYS.contains(p.getKey())) {
                prefScreen.removePreference(p);
            }
        }
    } else {
        // Dangerous privileges should be showing
        if (onScreenPrefs.length == WHITELISTED_DEVELOPER_PREF_KEYS.size()) {
            // If we're currently showing only white-listed prefs, reset
            reset();
        }
    }
}
 

@Override
public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
    Context context = getPreferenceManager().getContext();
    PreferenceScreen screen = getPreferenceManager().createPreferenceScreen(context);
    getPreferenceManager().getSharedPreferences().registerOnSharedPreferenceChangeListener(listener);

    Preference messageSchedule = new MessageSchedulePreference(context);
    Preference presenceTopic = new PresenceTopicPreference(context);

    Preference sendBatteryMessage = new SendBatteryMessagePreference(context);
    Preference batteryTopic = new BatteryTopicPreference(context);

    Preference autostart = new AutostartPreference(context);

    lastSuccess = new LastSuccessTimestampPreference(context);
    nextSchedule = new NextScheduleTimestampPreference(context);

    screen.addPreference(messageSchedule);
    screen.addPreference(presenceTopic);
    screen.addPreference(sendBatteryMessage);
    screen.addPreference(batteryTopic);
    screen.addPreference(autostart);
    screen.addPreference(lastSuccess);
    screen.addPreference(nextSchedule);

    setPreferenceScreen(screen);

    batteryTopic.setDependency(SEND_BATTERY_MESSAGE);
}
 

@Override
public void onCreatePreferences(final Bundle savedInstanceState, final String rootKey) {
    Context context = getPreferenceManager().getContext();
    PreferenceScreen screen = getPreferenceManager().createPreferenceScreen(context);

    Preference host = new HostPreference(context);
    Preference port = new PortPreference(context);

    Preference username = new UsernamePreference(context);
    Preference password = new PasswordPreference(context);

    Preference useTls = new UseTlsPreference(context);
    Preference clientCertificate = new ClientCertificatePreference(context, this);

    Preference checkConnection = new CheckConnectionDummy(context, this);

    screen.addPreference(host);
    screen.addPreference(port);
    screen.addPreference(username);
    screen.addPreference(password);
    screen.addPreference(useTls);
    screen.addPreference(clientCertificate);
    screen.addPreference(checkConnection);

    setPreferenceScreen(screen);

    checkConnection.setDependency(HOST);
    clientCertificate.setDependency(USE_TLS);
}
 

@Override
public boolean onPreferenceStartScreen(PreferenceFragment preferenceFragment,
                                       PreferenceScreen preferenceScreen) {
    PreferenceFragment frag = buildPreferenceFragment(R.xml.prefs, preferenceScreen.getKey());
    startPreferenceFragment(frag);
    return true;
}
 

@Override
public boolean onPreferenceStartScreen(PreferenceFragment preferenceFragment,
    PreferenceScreen preferenceScreen) {
    PreferenceFragment frag = buildPreferenceFragment(R.xml.settings,
        preferenceScreen.getKey());
    startPreferenceFragment(frag);
    return true;
}
 

private void removePreferencesWithGPVersion() {
    PreferenceScreen dnscryptSettings = findPreference("dnscrypt_settings");

    ArrayList<PreferenceCategory> categories = new ArrayList<>();
    categories.add(findPreference("pref_dnscrypt_forwarding_rules"));
    categories.add(findPreference("pref_dnscrypt_cloaking_rules"));
    categories.add(findPreference("pref_dnscrypt_blacklist"));
    categories.add(findPreference("pref_dnscrypt_ipblacklist"));
    categories.add(findPreference("pref_dnscrypt_whitelist"));
    categories.add(findPreference("pref_dnscrypt_other"));

    for (PreferenceCategory category : categories) {
        if (dnscryptSettings != null && category != null) {
            dnscryptSettings.removePreference(category);
        }
    }

    PreferenceCategory requireServersCategory = findPreference("dnscrypt_require_servers_prop_summ");
    Preference requireNofilter = findPreference("require_nofilter");

    if (requireServersCategory != null && requireNofilter != null) {
        requireServersCategory.removePreference(requireNofilter);
    }

    PreferenceCategory queryLogCategory = findPreference("pref_dnscrypt_query_log");
    Preference ignoredQtypes = findPreference("ignored_qtypes");

    if (queryLogCategory != null && ignoredQtypes != null) {
        queryLogCategory.removePreference(ignoredQtypes);
    }
}
 

private void changePreferencesForGPVersion() {
    PreferenceScreen preferencesFast = findPreference("fast_preferences");
    PreferenceCategory fastUpdateCategory = findPreference("fast_update");
    if (preferencesFast != null && fastUpdateCategory != null) {
        preferencesFast.removePreference(fastUpdateCategory);
    }

    PreferenceCategory fastOtherCategory = findPreference("fast_other");

    Preference blockHttp = findPreference("pref_fast_block_http");
    if (fastOtherCategory != null && blockHttp != null) {
        fastOtherCategory.removePreference(blockHttp);
    }
}
 

private void changePreferencesForFDVersion() {
    PreferenceScreen preferencesFast = findPreference("fast_preferences");
    PreferenceCategory fastUpdateCategory = findPreference("fast_update");
    if (preferencesFast != null && fastUpdateCategory != null) {
        preferencesFast.removePreference(fastUpdateCategory);
    }
}
 

@SuppressLint("RestrictedApi")
@Override
protected RecyclerView.Adapter onCreateAdapter(PreferenceScreen preferenceScreen) {
    return new PreferenceGroupAdapter(preferenceScreen) {
        @Override
        public void onPreferenceHierarchyChange(Preference preference) {
            if (preference != null)
                setAllPreferencesToAvoidHavingExtraSpace(preference);
            super.onPreferenceHierarchyChange(preference);
        }
    };
}
 

private void advancedPurchasedError(SharedPreferences sharedPreferences, PreferenceScreen preferenceScreen){
    advancedOptionsPurchased = false;
    sharedPreferences.edit().putBoolean(ADVANCED_PURCHASED_KEY, false).apply();
    preferenceScreen.findPreference(ADS_ENABLED_KEY).setEnabled(true);
    preferenceScreen.findPreference(ADS_ENABLED_KEY).setSummary(R.string.settingsAdsEnabledSummary);
    preferenceScreen.findPreference("pref_advanced_purchase").setSummary(R.string.settingsAdvancedPurchaseSummary);
    if (!adsEnabled) {
        preferenceScreen.findPreference("pref_advanced_options").setEnabled(false);
        sharedPreferences.edit().putBoolean(ADS_ENABLED_KEY, false).apply();
        preferenceScreen.findPreference(CUSTOM_NOTIFICATIONS_KEY).setEnabled(false);
        preferenceScreen.findPreference(SMART_NOTIFICATIONS_KEY).setEnabled(false);
        preferenceScreen.findPreference(NOTIF_AMOUNT_KEY).setEnabled(true);
        preferenceScreen.findPreference(DND_DELAY_KEY).setEnabled(false);
    }
}
 

@Override
public void onCreatePreferences(final Bundle savedInstanceState, final String rootKey) {
    super.onCreatePreferences(savedInstanceState, rootKey);
    Context activityContext = getActivity();

    final PreferenceScreen preferenceScreen = getPreferenceManager().createPreferenceScreen(activityContext);
    setPreferenceScreen(preferenceScreen);

    final TypedValue themeTypedValue = new TypedValue();
    activityContext.getTheme().resolveAttribute(R.attr.preferenceTheme, themeTypedValue, true);
    mContextThemeWrapper = new ContextThemeWrapper(activityContext, themeTypedValue.resourceId);
    mEmptyNotifications = new PreferenceCategory(mContextThemeWrapper);
    mEmptyNotifications.setTitle(R.string.id_your_notifications_will_be);
}
 

private void setupPrefs() {
    saveLocation = findPreference(getString(R.string.image_file_location_pref));
    if (MimiUtil.isSamsung()) {
        PreferenceScreen galleryScreen = (PreferenceScreen) findPreference(getString(R.string.gallery_prefs_screen));
        galleryScreen.removePreference(saveLocation);
        return;
    }

    DocumentFile saveDir = MimiUtil.getSaveDir();
    if (saveDir != null) {
        saveLocation.setSummary(saveDir.getName());
    }
    saveLocation.setOnPreferenceClickListener(preference -> {

        final int res;

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            res = getActivity().checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE);
        } else {
            res = ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE);
        }
        if (res == PackageManager.PERMISSION_GRANTED) {
            showDirChooser();
        } else {
            String[] perms = {Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE};

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                requestPermissions(perms, PERMISSIONS_CODE);
            } else {
                ActivityCompat.requestPermissions(getActivity(), perms, PERMISSIONS_CODE);
            }
        }

        return true;
    });
}
 

@Override
protected Adapter onCreateAdapter(PreferenceScreen preferenceScreen) {
  return new PreferenceGroupAdapter(preferenceScreen){
    @SuppressLint("RestrictedApi")
    public void onPreferenceHierarchyChange(Preference preference){
      setAllPreferencesToAvoidHavingExtraSpace(preference);
      super.onPreferenceHierarchyChange(preference);
    }
  };
}