Android
SharedPreferences

Вступление

Синтаксис

• Метод контекста

  • public SharedPreferences getSharedPreferences (String name, int mode)

• Способ действия

  • public SharedPreferences getPreferences ()

• Методы совместного доступа

  • public SharedPreferences.Editor edit ()
  • public boolean содержит ()
  • public Map <String,?> getAll ()
  • public boolean getBoolean (String key, boolean defValue)
  • public float getFloat (String key, float defValue)
  • public int getInt (String key, int defValue)
  • public long getLong (клавиша String, long defValue)
  • public String getString (String key, String defValue)
  • public Set getStringSet (клавиша String, Set defValues)
  • public void registerOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener)
  • public void unregisterOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener listener)

• Методы SharedPreferences.Editor

  • public void apply ()
  • public boolean commit ()
  • public SharedPreferences.Editor clear ()
  • public SharedPreferences.Editor putBoolean (Строковый ключ, логическое значение)
  • public SharedPreferences.Editor putFloat (String key, float value)
  • public SharedPreferences.Editor putInt (String key, int value)
  • public SharedPreferences.Editor putLong (Строковый ключ, длинное значение)
  • public SharedPreferences.Editor putString (String key, String value)
  • public SharedPreferences.Editor putStringSet (String key, Set values)
  • public SharedPreferences.Editor remove (String key)

параметры

замечания

Чтение и запись значений в SharedPreferences

public class MyActivity extends Activity {

    private static final String PREFS_FILE = "NameOfYourPrefrenceFile";
    // PREFS_MODE defines which apps can access the file
    private static final int PREFS_MODE = Context.MODE_PRIVATE;
    // you can use live template "key" for quickly creating keys
    private static final String KEY_BOOLEAN = "KEY_FOR_YOUR_BOOLEAN";
    private static final String KEY_STRING = "KEY_FOR_YOUR_STRING";
    private static final String KEY_FLOAT = "KEY_FOR_YOUR_FLOAT";
    private static final String KEY_INT = "KEY_FOR_YOUR_INT";
    private static final String KEY_LONG = "KEY_FOR_YOUR_LONG";

    @Override
    protected void onStart() {
        super.onStart();
    
        // Get the saved flag (or default value if it hasn't been saved yet)
        SharedPreferences settings = getSharedPreferences(PREFS_FILE, PREFS_MODE);
        // read a boolean value (default false)
        boolean booleanVal = settings.getBoolean(KEY_BOOLEAN, false);
        // read an int value (Default 0)
        int intVal = settings.getInt(KEY_INT, 0);
        // read a string value (default "my string")
        String str = settings.getString(KEY_STRING, "my string");
        // read a long value (default 123456)
        long longVal = settings.getLong(KEY_LONG, 123456);
        // read a float value (default 3.14f)
        float floatVal = settings.getFloat(KEY_FLOAT, 3.14f);
    }

    @Override
    protected void onStop() {
        super.onStop();
        
        // Save the flag
        SharedPreferences settings = getSharedPreferences(PREFS_FILE, PREFS_MODE);
        SharedPreferences.Editor editor = settings.edit();
        // write a boolean value
        editor.putBoolean(KEY_BOOLEAN, true);
        // write an integer value
        editor.putInt(KEY_INT, 123);
        // write a string
        editor.putString(KEY_STRING, "string value");
        // write a long value
        editor.putLong(KEY_LONG, 456876451);
        // write a float value
        editor.putFloat(KEY_FLOAT, 1.51f);
        editor.apply();
    }
}

getSharedPreferences() представляет собой метод из Context класса - который Activity продолжается. Если вам нужен доступ к getSharedPreferences() из других классов, вы можете использовать context.getSharedPreferences() с ссылкой на объект Context из Activity , View или Application .

Удаление ключей

private static final String MY_PREF = "MyPref";

// ...

SharedPreferences prefs = ...;

// ...

SharedPreferences.Editor editor = prefs.edit();
editor.putString(MY_PREF, "value");
editor.remove(MY_PREF);
editor.apply();

После apply() prefs содержит «ключ» -> «значение», в дополнение к тому, что он уже содержит. Хотя похоже, что я добавил «ключ», а затем удалил его, сначала происходит удаление. Изменения в Editor все применяются за один раз, а не в том порядке, в котором вы их добавили. Все удары происходят до всех пометок.

Реализация экрана настроек с использованием SharedPreferences

Одно использование SharedPreferences заключается в реализации экрана «Настройки» в вашем приложении, где пользователь может установить свои настройки / параметры. Как это:

A PreferenceScreen сохраняет пользовательские настройки в SharedPreferences . Чтобы создать PreferenceScreen, вам нужно несколько вещей:

XML-файл для определения доступных параметров:

Это происходит в /res/xml/preferences.xml , и для экрана с приведенными выше настройками он выглядит следующим образом:

<PreferenceScreen
    xmlns:android="http://schemas.android.com/apk/res/android">
    <PreferenceCategory
        android:title="General options">
        <CheckBoxPreference
            android:key = "silent_mode"
            android:defaultValue="false"
            android:title="Silent Mode"
            android:summary="Mute all sounds from this app" />

        <SwitchPreference
            android:key="awesome_mode"
            android:defaultValue="false"
            android:switchTextOn="Yes"
            android:switchTextOff="No"
            android:title="Awesome mode™"
            android:summary="Enable the Awesome Mode™ feature"/>

        <EditTextPreference
            android:key="custom_storage"
            android:defaultValue="/sdcard/data/"
            android:title="Custom storage location"
            android:summary="Enter the directory path where you want data to be saved. If it does not exist, it will be created."
            android:dialogTitle="Enter directory path (eg. /sdcard/data/ )"/>
    </PreferenceCategory>
</PreferenceScreen>

Это определяет доступные параметры на экране настроек. Есть много других типов Preference перечисленных в документации разработчиков Android в классе предпочтений .

Затем нам понадобится Activity для размещения пользовательского интерфейса Preferences . В этом случае он довольно короткий и выглядит следующим образом:

package com.example.preferences;

import android.preference.PreferenceActivity;
import android.os.Bundle;

public class PreferencesActivity extends PreferenceActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
    }
}

Он расширяет PreferenceActivity и предоставляет пользовательский интерфейс для экрана настроек. Его можно запустить как обычную активность, в данном случае, с чем-то вроде:

Intent i = new Intent(this, PreferencesActivity.class);
startActivity(i);

Не забудьте добавить PreferencesActivity в ваш AndroidManifest.xml .

Получение значений параметров внутри вашего приложения довольно просто, просто setDefaultValues() вызовите setDefaultValues() , чтобы установить значения по умолчанию, определенные в вашем XML, а затем получить стандартные SharedPreferences . Пример:

//set the default values we defined in the XML
PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
    
//get the values of the settings options
boolean silentMode = preferences.getBoolean("silent_mode", false);
boolean awesomeMode = preferences.getBoolean("awesome_mode", false);
    
String customStorage = preferences.getString("custom_storage", "");

Извлеките все сохраненные записи из определенного файла SharedPreferences

Метод getAll() извлекает все значения из настроек. Мы можем использовать его, например, для регистрации текущего содержимого SharedPreferences :

private static final String PREFS_FILE = "MyPrefs";

public static void logSharedPreferences(final Context context) {
    SharedPreferences sharedPreferences = context.getSharedPreferences(PREFS_FILE, Context.MODE_PRIVATE);
    Map<String, ?> allEntries = sharedPreferences.getAll();
    for (Map.Entry<String, ?> entry : allEntries.entrySet()) {
        final String key = entry.getKey();
        final Object value = entry.getValue();
        Log.d("map values", key + ": " + value);
    } 
}

Документация предупреждает вас об изменении Collection возвращенной getAll :

Обратите внимание, что вы не должны изменять коллекцию, возвращаемую этим методом, или изменять любое ее содержимое. Согласованность сохраненных вами данных не гарантируется, если вы это сделаете.

Прослушивание изменений SharedPreferences

SharedPreferences sharedPreferences = ...;
sharedPreferences.registerOnSharedPreferenceChangeListener(mOnSharedPreferenceChangeListener);


private final SharedPreferences.OnSharedPreferenceChangeListener mOnSharedPreferenceChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        //TODO
    }
}

Пожалуйста, обратите внимание:

• Слушатель будет стрелять, только если значение было добавлено или изменено, установка того же значения не вызовет его;
• Слушатель должен быть сохранен в переменной-члене, а НЕ с анонимным классом, потому что registerOnSharedPreferenceChangeListener сохраняет его со слабой ссылкой, поэтому это будет сбор мусора;
• Вместо использования переменной-члена она также может быть непосредственно реализована классом, а затем вызывает registerOnSharedPreferenceChangeListener(this);
• Не забудьте отменить регистрацию слушателя, когда это не требуется, используя unregisterOnSharedPreferenceChangeListener .

Чтение и запись данных в SharedPreferences с Singleton

SharedPreferences Manager (Singleton) для чтения и записи всех типов данных.

import android.content.Context;
import android.content.SharedPreferences;
import android.util.Log;

import com.google.gson.Gson;

import java.lang.reflect.Type;

/**
 * Singleton Class for accessing SharedPreferences,
 * should be initialized once in the beginning by any application component using static
 * method initialize(applicationContext)
 */
public class SharedPrefsManager {
    
    private static final String TAG = SharedPrefsManager.class.getName();
    private SharedPreferences prefs;
    private static SharedPrefsManager uniqueInstance;
    public static final String PREF_NAME = "com.example.app";

    private SharedPrefsManager(Context appContext) {
        prefs = appContext.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
    }

    /**
     * Throws IllegalStateException if this class is not initialized
     *
     * @return unique SharedPrefsManager instance
     */
    public static SharedPrefsManager getInstance() {
        if (uniqueInstance == null) {
            throw new IllegalStateException(
                    "SharedPrefsManager is not initialized, call initialize(applicationContext) " +
                            "static method first");
        }
        return uniqueInstance;
    }

    /**
     * Initialize this class using application Context,
     * should be called once in the beginning by any application Component
     *
     * @param appContext application context
     */
    public static void initialize(Context appContext) {
        if (appContext == null) {
            throw new NullPointerException("Provided application context is null");
        }
        if (uniqueInstance == null) {
            synchronized (SharedPrefsManager.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new SharedPrefsManager(appContext);
                }
            }
        }
    }

    private SharedPreferences getPrefs() {
        return prefs;
    }

    /**
     * Clears all data in SharedPreferences
     */
    public void clearPrefs() {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.clear();
        editor.commit();
    }

    public void removeKey(String key) {
        getPrefs().edit().remove(key).commit();
    }

    public boolean containsKey(String key) {
        return getPrefs().contains(key);
    }

    public String getString(String key, String defValue) {
        return getPrefs().getString(key, defValue);
    }

    public String getString(String key) {
        return getString(key, null);
    }

    public void setString(String key, String value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putString(key, value);
        editor.apply();
    }

    public int getInt(String key, int defValue) {
        return getPrefs().getInt(key, defValue);
    }

    public int getInt(String key) {
        return getInt(key, 0);
    }

    public void setInt(String key, int value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putInt(key, value);
        editor.apply();
    }

    public long getLong(String key, long defValue) {
        return getPrefs().getLong(key, defValue);
    }

    public long getLong(String key) {
        return getLong(key, 0L);
    }

    public void setLong(String key, long value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putLong(key, value);
        editor.apply();
    }

    public boolean getBoolean(String key, boolean defValue) {
        return getPrefs().getBoolean(key, defValue);
    }

    public boolean getBoolean(String key) {
        return getBoolean(key, false);
    }

    public void setBoolean(String key, boolean value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putBoolean(key, value);
        editor.apply();
    }

    public boolean getFloat(String key) {
        return getFloat(key, 0f);
    }

    public boolean getFloat(String key, float defValue) {
        return getFloat(key, defValue);
    }

    public void setFloat(String key, Float value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putFloat(key, value);
        editor.apply();
    }

    /**
     * Persists an Object in prefs at the specified key, class of given Object must implement Model
     * interface
     *
     * @param key         String
     * @param modelObject Object to persist
     * @param <M>         Generic for Object
     */
    public <M extends Model> void setObject(String key, M modelObject) {
        String value = createJSONStringFromObject(modelObject);
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putString(key, value);
        editor.apply();
    }

    /**
     * Fetches the previously stored Object of given Class from prefs
     *
     * @param key                String
     * @param classOfModelObject Class of persisted Object
     * @param <M>                Generic for Object
     * @return Object of given class
     */
    public <M extends Model> M getObject(String key, Class<M> classOfModelObject) {
        String jsonData = getPrefs().getString(key, null);
        if (null != jsonData) {
            try {
                Gson gson = new Gson();
                M customObject = gson.fromJson(jsonData, classOfModelObject);
                return customObject;
            } catch (ClassCastException cce) {
                Log.d(TAG, "Cannot convert string obtained from prefs into collection of type " +
                        classOfModelObject.getName() + "\n" + cce.getMessage());
            }
        }
        return null;
    }

    /**
     * Persists a Collection object in prefs at the specified key
     *
     * @param key            String
     * @param dataCollection Collection Object
     * @param <C>            Generic for Collection object
     */
    public <C> void setCollection(String key, C dataCollection) {
        SharedPreferences.Editor editor = getPrefs().edit();
        String value = createJSONStringFromObject(dataCollection);
        editor.putString(key, value);
        editor.apply();
    }

    /**
     * Fetches the previously stored Collection Object of given type from prefs
     *
     * @param key     String
     * @param typeOfC Type of Collection Object
     * @param <C>     Generic for Collection Object
     * @return Collection Object which can be casted
     */
    public <C> C getCollection(String key, Type typeOfC) {
        String jsonData = getPrefs().getString(key, null);
        if (null != jsonData) {
            try {
                Gson gson = new Gson();
                C arrFromPrefs = gson.fromJson(jsonData, typeOfC);
                return arrFromPrefs;
            } catch (ClassCastException cce) {
                Log.d(TAG, "Cannot convert string obtained from prefs into collection of type " +
                        typeOfC.toString() + "\n" + cce.getMessage());
            }
        }
        return null;
    }

    public void registerPrefsListener(SharedPreferences.OnSharedPreferenceChangeListener listener) {
        getPrefs().registerOnSharedPreferenceChangeListener(listener);
    }

    public void unregisterPrefsListener(

            SharedPreferences.OnSharedPreferenceChangeListener listener) {
        getPrefs().unregisterOnSharedPreferenceChangeListener(listener);
    }

    public SharedPreferences.Editor getEditor() {
        return getPrefs().edit();
    }

    private static String createJSONStringFromObject(Object object) {
        Gson gson = new Gson();
        return gson.toJson(object);
    } 
}

interface Model который реализуется классами, идущими в Gson чтобы избежать обфускации proguard.

public interface Model {
    
}

Правила Proguard для интерфейса Model :

-keep interface com.example.app.Model
-keep class * implements com.example.app.Model { *;}

Различные способы создания объекта SharedPreferences

Вы можете получить доступ к SharedPreferences несколькими способами:

Получить файл SharedPreferences по умолчанию:

import android.preference.PreferenceManager;
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

Получить определенный файл SharedPreferences:

public static final String PREF_FILE_NAME = "PrefFile";
SharedPreferences prefs = getSharedPreferences(PREF_FILE_NAME, MODE_PRIVATE);

Получить SharedPreferences из другого приложения:

// Note that the other app must declare prefs as MODE_WORLD_WRITEABLE
final ArrayList<HashMap<String,String>> LIST = new ArrayList<HashMap<String,String>>();
Context contextOtherApp = createPackageContext("com.otherapp", Context.MODE_WORLD_WRITEABLE);
SharedPreferences prefs = contextOtherApp.getSharedPreferences("pref_file_name", Context.MODE_WORLD_READABLE); 

getPreferences (int) VS getSharedPreferences (String, int)

getPreferences(int)

возвращает предпочтения, сохраненные Activity's class name как описано в документах :

Извлеките объект SharedPreferences для доступа к предпочтениям, которые являются приватными для этого действия. Это просто вызывает базовый метод getSharedPreferences (String, int), передавая имя класса этой активности в качестве имени предпочтений.

При использовании метода getSharedPreferences (String name, int mode) возвращает префы, сохраненные под заданным name . Как и в документах:

Извлеките и сохраните содержимое файла настроек «имя», возвращая SharedPreferences, через который вы можете получить и изменить свои значения.

Поэтому, если значение, сохраненное в SharedPreferences , должно использоваться в приложении, следует использовать getSharedPreferences (String name, int mode) с фиксированным именем. Поскольку, используя getPreferences(int) возвращает / сохраняет предпочтения, принадлежащие вызывающей его Activity .

Commit vs. Apply

Метод editor.apply() является асинхронным , а editor.commit() является синхронным .

Очевидно, вы должны вызвать либо apply() либо commit() .

SharedPreferences settings = getSharedPreferences(PREFS_FILE, MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(PREF_CONST, true);
// This will asynchronously save the shared preferences without holding the current thread.
editor.apply();

SharedPreferences settings = getSharedPreferences(PREFS_FILE, MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(PREF_CONST, true);
// This will synchronously save the shared preferences while holding the current thread until done and returning a success flag.
boolean result = editor.commit();

apply() был добавлен в 2.3 (API 9), он совершает ошибку, не возвращая логическое значение, указывающее на успех или неудачу.

commit() возвращает true, если сохранение работает, в противном случае false.

apply() была добавлена, поскольку команда разработчиков Android заметила, что почти никто не обратил внимание на возвращаемое значение, поэтому применение выполняется быстрее, так как оно асинхронно.

В отличие от commit() , который синхронно записывает свои предпочтения в постоянное хранилище, apply() немедленно выполняет изменения в SharedPreferences в памяти, но начинает асинхронную фиксацию на диск, и вы не будете уведомлены о каких-либо сбоях. Если другой редактор этой SharedPreferences выполняет регулярную commit() а apply() по-прежнему SharedPreferences , commit() будет блокироваться до тех пор, пока все асинхронные транзакции (применение) не будут завершены, а также любые другие транзакции синхронизации, которые могут быть отложены.

Поддерживаемые типы данных в SharedPreferences

SharedPreferences позволяет вам хранить только примитивные типы данных ( boolean , float , long , int , String и string set ). Вы не можете хранить более сложные объекты в SharedPreferences , и как таковое действительно предназначено для хранения пользовательских настроек или аналогичных, это не означает, что база данных хранит пользовательские данные (например, сохранение списка задач, например, пользователя).

Чтобы сохранить что-то в SharedPreferences вы используете ключ и значение. Ключ - это то, как вы можете ссылаться на то, что вы сохранили позже, и данные Value, которые вы хотите сохранить.

    String keyToUseToFindLater = "High Score";
    int newHighScore = 12938;
    //getting SharedPreferences & Editor objects 
    SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sharedPref.edit();
    //saving an int in the SharedPreferences file
    editor.putInt(keyToUseToFindLater, newHighScore);
    editor.commit();

Хранить, извлекать, удалять и очищать данные из общих ресурсов

Создать SharedPreferences BuyyaPref

SharedPreferences pref = getApplicationContext().getSharedPreferences("BuyyaPref", MODE_PRIVATE); 
Editor editor = pref.edit();

Хранение данных в виде пары KEY / VALUE

editor.putBoolean("key_name1", true);           // Saving boolean - true/false
editor.putInt("key_name2", 10);        // Saving integer
editor.putFloat("key_name3", 10.1f);    // Saving float
editor.putLong("key_name4", 1000);      // Saving long
editor.putString("key_name5", "MyString");  // Saving string
 
// Save the changes in SharedPreferences
editor.commit(); // commit changes

Получить данные SharedPreferences

Если значение для ключа не существует, верните второе значение параметра (в этом случае значение null, это как значение по умолчанию)

pref.getBoolean("key_name1", null);         // getting boolean
pref.getInt("key_name2", null);             // getting Integer
pref.getFloat("key_name3", null);           // getting Float
pref.getLong("key_name4", null);            // getting Long
pref.getString("key_name5", null);          // getting String

Удаление значения ключа из SharedPreferences

editor.remove("key_name3"); // will delete key key_name3
editor.remove("key_name4"); // will delete key key_name4
 
// Save the changes in SharedPreferences
editor.commit(); // commit changes

Очистить все данные из SharedPreferences

 editor.clear();
 editor.commit(); // commit changes

Поддержка pre-Honeycomb с помощью StringSet

Вот класс утилиты:

public class SharedPreferencesCompat {

    public static void putStringSet(SharedPreferences.Editor editor, String key, Set<String> values) {
            if (Build.VERSION.SDK_INT >= 11) {
                while (true) {
                    try {
                        editor.putStringSet(key, values).apply();
                        break;
                    } catch (ClassCastException ex) {
                        // Clear stale JSON string from before system upgrade
                        editor.remove(key);
                    }
                }
            } else putStringSetToJson(editor, key, values);
    }

    public static Set<String> getStringSet(SharedPreferences prefs, String key, Set<String> defaultReturnValue) {
        if (Build.VERSION.SDK_INT >= 11) {
            try {
                return prefs.getStringSet(key, defaultReturnValue);
            } catch (ClassCastException ex) {
                // If user upgraded from Gingerbread to something higher read the stale JSON string
                return getStringSetFromJson(prefs, key, defaultReturnValue);
            }
        } else return getStringSetFromJson(prefs, key, defaultReturnValue);
    }

    private static Set<String> getStringSetFromJson(SharedPreferences prefs, String key, Set<String> defaultReturnValue) {
        final String input = prefs.getString(key, null);
        if (input == null) return defaultReturnValue;

        try {
            HashSet<String> set = new HashSet<>();
            JSONArray json = new JSONArray(input);
            for (int i = 0, size = json.length(); i < size; i++) {
                String value = json.getString(i);
                set.add(value);
            }
            return set;
        } catch (JSONException e) {
            e.printStackTrace();
            return defaultReturnValue;
        }
    }

    private static void putStringSetToJson(SharedPreferences.Editor editor, String key, Set<String> values) {
        JSONArray json = new JSONArray(values);
        if (Build.VERSION.SDK_INT >= 9)
            editor.putString(key, json.toString()).apply();
        else
            editor.putString(key, json.toString()).commit();
    }

    private SharedPreferencesCompat() {}
}

Пример сохранения предпочтений в виде типа данных StringSet:

Set<String> sets = new HashSet<>();
sets.add("John");
sets.add("Nicko");
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferencesCompat.putStringSet(preferences.edit(), "pref_people", sets);

Чтобы вернуть их обратно:

Set<String> people = SharedPreferencesCompat.getStringSet(preferences, "pref_people", new HashSet<String>());

Ссылка: поддержка Android

Добавить фильтр для EditTextPreference

Создайте этот класс:

public class InputFilterMinMax implements InputFilter {

    private int min, max;

    public InputFilterMinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public InputFilterMinMax(String min, String max) {
        this.min = Integer.parseInt(min);
        this.max = Integer.parseInt(max);
    }

    @Override
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
        try {
            int input = Integer.parseInt(dest.toString() + source.toString());
            if (isInRange(min, max, input))
                return null;
        } catch (NumberFormatException nfe) { }
        return "";
    }

    private boolean isInRange(int a, int b, int c) {
        return b > a ? c >= a && c <= b : c >= b && c <= a;
    }
}

Использование:

EditText compressPic = ((EditTextPreference) findPreference(getString("pref_key_compress_pic"))).getEditText();
compressPic.setFilters(new InputFilter[]{ new InputFilterMinMax(1, 100) });