Android
SharedPreferences

Introduktion

Syntax

• Kontextmetod

  • offentliga SharedPreferences getSharedPreferences (String name, int mode)

• Aktivitetsmetod

  • public SharedPreferences getPreferences ()

• SharedPreferences-metoder

  • public SharedPreferences.Editor redigera ()
  • offentlig boolean innehåller ()
  • offentlig karta <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 key, long defValue)
  • public String getString (String key, String defValue)
  • public Set getStringSet (String key, Set defValues)
  • public void registerOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener lyssnaren)
  • public void unregisterOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener lyssnaren)

• SharedPreferences.Editor Methods

  • offentligt ogiltigt tillämpas ()
  • offentliga booleska engagemang ()
  • public SharedPreferences.Editor clear ()
  • public SharedPreferences.Editor putBoolean (String key, boolean value)
  • public SharedPreferences.Editor putFloat (String key, float value)
  • public SharedPreferences.Editor putInt (String key, int value)
  • public SharedPreferences.Editor putLong (strängnyckel, långt värde)
  • public SharedPreferences.Editor putString (String key, String value)
  • public SharedPreferences.Editor putStringSet (strängnyckel, ställa in värden)
  • public SharedPreferences.Editor remove (String key)

parametrar

Anmärkningar

Läs och skriv värden till 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() är en metod från klassen Context - vilken Activity utvidgas. Om du behöver komma till getSharedPreferences() från andra klasser kan du använda context.getSharedPreferences() med en hänvisning till ett Context från en Activity , View eller Application .

Ta bort nycklar

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();

Efter apply() innehåller prefs "nyckel" -> "värde", utöver vad det redan innehöll. Även om det ser ut som om jag har lagt till "nyckel" och sedan tagit bort den, sker faktiskt först. Ändringarna i Editor tillämpas alla på en gång, inte i den ordning du har lagt till dem. Alla borttagningar händer innan alla sätter.

Implementera en skärm för inställningar med SharedPreferences

En användning av SharedPreferences är att implementera en "Inställningar" -skärm i din app, där användaren kan ställa in sina preferenser / alternativ. Så här:

En PreferenceScreen sparar användarinställningar i SharedPreferences . För att skapa en PreferenceScreen behöver du några saker:

En XML-fil för att definiera tillgängliga alternativ:

Detta går i /res/xml/preferences.xml , och för inställningsskärmen ovan ser det ut så här:

<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>

Detta definierar tillgängliga alternativ på inställningsskärmen. Det finns många andra typer av Preference anges i dokumentationen för Android-utvecklare om Preference Class .

Därefter behöver vi en aktivitet för att vara värd för vårt inställnings användargränssnitt. I det här fallet är det ganska kort och ser ut så här:

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

Det utökar PreferenceActivity och ger användargränssnittet för skärmen med preferenser. Det kan startas precis som en normal aktivitet, i det här fallet, med något som:

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

Glöm inte att lägga till PreferencesActivity till din AndroidManifest.xml .

Att få värdena på inställningarna i din app är ganska enkelt, ring bara setDefaultValues() först för att ställa in standardvärdena som definierats i din XML och sedan få standard SharedPreferences . Ett exempel:

//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", "");

Hämta alla lagrade poster från en viss SharedPreferences-fil

getAll() hämtar alla värden från inställningarna. Vi kan till exempel använda det för att logga det aktuella innehållet i 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);
    } 
}

Dokumentationen varnar dig för att ändra den Collection returneras av getAll :

Observera att du inte får ändra den samling som returneras med den här metoden eller ändra något av dess innehåll. Konsistensen för dina lagrade data garanteras inte om du gör det.

Lyssna på SharedPreferences förändringar

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


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

Vänligen notera:

• Lyssnaren kommer bara att avfyras om värdet lades till eller ändrades, om du sätter samma värde kommer inte att kalla det;
• Lyssnaren måste sparas i en medlemsvariabel och INTE med en anonym klass, eftersom registerOnSharedPreferenceChangeListener lagrar den med en svag referens, så det skulle vara skräp som samlas in;
• Istället för att använda en medlemsvariabel kan den också implementeras direkt av klassen och sedan ringa registerOnSharedPreferenceChangeListener(this);
• Kom ihåg att avregistrera lyssnaren när det inte längre krävs med unregisterOnSharedPreferenceChangeListener .

Läsa och skriva data till SharedPreferences med Singleton

SharedPreferences Manager (Singleton) klass för att läsa och skriva alla typer av data.

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

Model interface som genomförs av klasser kommer att Gson att undvika ProGuard förvirring.

public interface Model {
    
}

Proguard regler för Model interface:

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

Olika sätt att instansera ett objekt med SharedPreferences

Du kan komma åt SharedPreferences på flera sätt:

Hämta standard SharedPreferences-filen:

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

Skaffa en specifik SharedPreferences-fil:

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

Hämta SharedPreferences från en annan app:

// 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)

returnerar de inställningar som sparats av Activity's class name som beskrivs i dokumenten :

Hämta ett SharedPreferences-objekt för åtkomst till preferenser som är privata för denna aktivitet. Detta kallar helt enkelt den underliggande metoden getSharedPreferences (String, int) genom att lämna in denna aktivitets klassnamn som preferensnamnet.

När du använder getSharedPreferences (String name, int mode) -metoden returnerar de kön som sparats under det givna name . Som i dokumenten:

Hämta och håll inne innehållet i preferensfilen 'namn' och returnera en SharedPreferences genom vilken du kan hämta och ändra dess värden.

Så om värdet som sparas i SharedPreferences måste användas över appen, bör man använda getSharedPreferences (String name, int mode) med ett fast namn. Som att använda getPreferences(int) returnerar / sparar de preferenser som tillhör den Activity kallar det.

Åtagande kontra ansöka

editor.apply() är asynkron , medan editor.commit() är synkron .

Uppenbarligen bör du ringa antingen apply() eller 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() lades till i 2.3 (API 9), det återstår utan att returnera en boolean som indikerar framgång eller misslyckande.

commit() returnerar sant om spara fungerar, falskt annars.

apply() lades till när Android dev-teamet märkte att nästan ingen noterade returvärdet, så tillämpningen är snabbare eftersom det är asynkron.

Till skillnad från commit() , som skriver sina inställningar ut till bestående lagring synkront, apply() återställer sina ändringar i SharedPreferences minnet omedelbart men startar en asynkron engagemang på disken och du kommer inte att meddelas om några fel. Om en annan redaktör på denna SharedPreferences gör ett vanligt commit() medan en apply() fortfarande är utestående, kommer commit() att blockeras tills alla async-åtaganden (tillämpas) är slutförda samt alla andra synkroniseringsåtgärder som kan vänta.

Stödda datatyper i SharedPreferences

SharedPreferences kan du bara lagra primitiva datatyper ( boolean , float , long , int , String och string set ). Du kan inte lagra mer komplexa objekt i SharedPreferences , och som sådan är det verkligen tänkt att vara en plats att lagra användarinställningar eller liknande, det är inte avsett att vara en databas för att behålla användardata (som att spara en todo-lista som en användare gjort till exempel).

För att lagra något i SharedPreferences använder du en nyckel och ett värde. Nyckeln är hur du kan referera till vad du lagrade senare och de värdedata som du vill lagra.

    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();

Lagra, hämta, ta bort och rensa data från SharedPreferences

Skapa SharedPreferences BuyyaPref

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

Lagring av data som KEY / VALUE-par

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

Hämta SharedPreferences-data

Om värde för nyckel inte finns, returnera andra parametervärde (i detta fall null, det är som standardvärde)

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

Radera nyckelvärde från 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

Rensa all data från SharedPreferences

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

Stöd pre-honungskaka med StringSet

Här är verktygsklassen:

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() {}
}

Ett exempel för att spara inställningar som StringSet-datatyp är:

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

För att hämta dem tillbaka:

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

Referens: Android Support Preference

Lägg till filter för EditTextPreference

Skapa den här klassen:

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

Använda sig av :

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