que - sharedpreferences android code

¿Es posible agregar una matriz u objeto a SharedPreferences en Android?

Question

Tengo un ArrayList de objetos que tienen un nombre y un puntero de icono y quiero guardarlo en SharedPreferences . ¿Como lo puedo hacer?

NOTA: no quiero usar la base de datos

Answer 1

Cargué una matriz de tamaños de cintura (ya creados en mi matriz.xml) en mi archivo preferences.xml con el código siguiente. @ array / pant_inch_size es la identificación de toda la matriz.

 <ListPreference 
 android:title="choosepantsize"
 android:summary="Choose Pant Size"
 android:key="pantSizePref" 
 android:defaultValue="34" 
 android:entries="@array/pant_inch_size"
 android:entryValues="@array/pant_inch_size" /> 

Esto llenó el menú con opciones de la matriz. Configuré el tamaño predeterminado como 34, por lo que cuando aparece el menú, ven que el tamaño 34 está preseleccionado.

Answer 2

Entonces desde el sitio del desarrollador de Android en Data Storage :

Preferencias de usuario

Las preferencias compartidas no son estrictamente para guardar "preferencias de usuario" , como qué tono de llamada ha elegido un usuario. Si está interesado en crear preferencias de usuario para su aplicación, consulte PreferenceActivity, que proporciona un marco de actividad para que pueda crear preferencias de usuario, que se conservarán automáticamente (utilizando las preferencias compartidas).

Así que creo que está bien, ya que simplemente son pares clave-valor los que persisten.

Para el cartel original, esto no es tan difícil. Simplemente itere a través de su lista de matriz y agregue los elementos. En este ejemplo, utilizo un mapa para simplificar, pero puede usar una lista de arreglos y cambiarla apropiadamente:

// my list of names, icon locations
Map<String, String> nameIcons = new HashMap<String, String>();
nameIcons.put("Noel", "/location/to/noel/icon.png");
nameIcons.put("Bob", "another/location/to/bob/icon.png");
nameIcons.put("another name", "last/location/icon.png");

SharedPreferences keyValues = getContext().getSharedPreferences("name_icons_list", Context.MODE_PRIVATE);
SharedPreferences.Editor keyValuesEditor = keyValues.edit();

for (String s : nameIcons.keySet()) {
    // use the name as the key, and the icon as the value
    keyValuesEditor.putString(s, nameIcons.get(s));
}
keyValuesEditor.commit()

Haría algo similar para leer los pares clave-valor nuevamente. Hazme saber si esto funciona.

Actualización: si está utilizando el nivel 11 de API o posterior, hay un method para escribir un conjunto de cadenas

Answer 3

Escribir,

SharedPreferences prefs = PreferenceManager
        .getDefaultSharedPreferences(this);
JSONArray jsonArray = new JSONArray();
jsonArray.put(1);
jsonArray.put(2);
Editor editor = prefs.edit();
editor.putString("key", jsonArray.toString());
System.out.println(jsonArray.toString());
editor.commit();

Leer,

try {
    JSONArray jsonArray2 = new JSONArray(prefs.getString("key", "[]"));
    for (int i = 0; i < jsonArray2.length(); i++) {
         Log.d("your JSON Array", jsonArray2.getInt(i)+"");
    }
} catch (Exception e) {
    e.printStackTrace();
}

Answer 4

Este es el código de preferencias compartidas que uso con éxito. Consulte este link :

  public class MainActivity extends Activity {

private static final int RESULT_SETTINGS = 1;
Button button;
public String a="dd";

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

 button = (Button) findViewById(R.id.btnoptions);


setContentView(R.layout.activity_main);

  // showUserSettings();
  }

@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.settings, menu);
return true;
 }

@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {

case R.id.menu_settings:
 Intent i = new Intent(this, UserSettingActivity.class);
 startActivityForResult(i, RESULT_SETTINGS);
 break;

 }

return true;
}

@Override
 protected void onActivityResult(int requestCode, int resultCode, Intent data)     {
  super.onActivityResult(requestCode, resultCode, data);

 switch (requestCode) {
 case RESULT_SETTINGS:
 showUserSettings();
 break;

 } 

  }

  private void showUserSettings() {
 SharedPreferences sharedPrefs = PreferenceManager
.getDefaultSharedPreferences(this);

 StringBuilder builder = new StringBuilder();

 builder.append("/n Pet: "
  + sharedPrefs.getString("prefpetname", "NULL"));

 builder.append("/n Address:"
 + sharedPrefs.getString("prefaddress","NULL" ));

 builder.append("/n Your name: "
 + sharedPrefs.getString("prefname", "NULL"));

 TextView settingsTextView = (TextView) findViewById(R.id.textUserSettings);


  settingsTextView.setText(builder.toString());


    }

   }

¡CÓDIGO FELIZ!

Answer 5

Independientemente del nivel de API, compruebe matrices de cadenas y matrices de objetos en SharedPreferences

GUARDAR ARRAY

public boolean saveArray(String[] array, String arrayName, Context mContext) {   
    SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);  
    SharedPreferences.Editor editor = prefs.edit();  
    editor.putInt(arrayName +"_size", array.length);  
    for(int i=0;i<array.length;i++)  
        editor.putString(arrayName + "_" + i, array[i]);  
    return editor.commit();  
} 

LOAD ARRAY

public String[] loadArray(String arrayName, Context mContext) {  
    SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);  
    int size = prefs.getInt(arrayName + "_size", 0);  
    String array[] = new String[size];  
    for(int i=0;i<size;i++)  
        array[i] = prefs.getString(arrayName + "_" + i, null);  
    return array;  
}  

Answer 6

La forma simple es convertirlo a cadena JSON como se muestra a continuación:

Gson gson = new Gson();
String json = gson.toJson(myObj);

Luego, guarde la cadena en las preferencias compartidas. Una vez que lo necesite, solo obtenga una cadena de las preferencias compartidas y vuelva a convertirla en JSONArray o JSONObject (según su requisito).

Answer 7

Las preferencias compartidas introdujeron los métodos getStringSet y putStringSet en el nivel 11 de la API, pero eso no es compatible con las versiones anteriores de Android (que todavía son populares), y también está limitado a conjuntos de cadenas.

Android no proporciona mejores métodos, y el bucle sobre los mapas y las matrices para guardarlos y cargarlos no es muy fácil y limpio, especialmente para las matrices. Pero una mejor implementación no es tan difícil:

package com.example.utils;

import org.json.JSONObject;
import org.json.JSONArray;
import org.json.JSONException;

import android.content.Context;
import android.content.SharedPreferences;

public class JSONSharedPreferences {
    private static final String PREFIX = "json";

    public static void saveJSONObject(Context c, String prefName, String key, JSONObject object) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        SharedPreferences.Editor editor = settings.edit();
        editor.putString(JSONSharedPreferences.PREFIX+key, object.toString());
        editor.commit();
    }

    public static void saveJSONArray(Context c, String prefName, String key, JSONArray array) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        SharedPreferences.Editor editor = settings.edit();
        editor.putString(JSONSharedPreferences.PREFIX+key, array.toString());
        editor.commit();
    }

    public static JSONObject loadJSONObject(Context c, String prefName, String key) throws JSONException {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        return new JSONObject(settings.getString(JSONSharedPreferences.PREFIX+key, "{}"));
    }

    public static JSONArray loadJSONArray(Context c, String prefName, String key) throws JSONException {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        return new JSONArray(settings.getString(JSONSharedPreferences.PREFIX+key, "[]"));
    }

    public static void remove(Context c, String prefName, String key) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        if (settings.contains(JSONSharedPreferences.PREFIX+key)) {
            SharedPreferences.Editor editor = settings.edit();
            editor.remove(JSONSharedPreferences.PREFIX+key);
            editor.commit();
        }
    }
}

Ahora puede guardar cualquier colección en preferencias compartidas con estos cinco métodos. Trabajar con JSONObject y JSONArray es muy fácil. Puede utilizar el constructor público JSONArray (Collection copyFrom) para crear un JSONArray de cualquier colección Java y utilizar los métodos get JSONArray para acceder a los elementos.

No hay límite de tamaño para las preferencias compartidas (además de los límites de almacenamiento del dispositivo), por lo que estos métodos pueden funcionar para la mayoría de los casos habituales en los que desea un almacenamiento rápido y fácil para una colección en su aplicación. Pero el análisis JSON ocurre aquí, y las preferencias en Android se almacenan como XML internamente, por lo que recomiendo utilizar otros mecanismos de almacenamiento de datos persistentes cuando se trata de megabytes de datos.

Answer 8

Modo fácil para el almacenamiento de objetos complejos con el uso de la biblioteca de Google Gson [1]

public static void setComplexObject(Context ctx, ComplexObject obj){
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
    SharedPreferences.Editor editor = preferences.edit();
    editor.putString("COMPLEX_OBJECT",new Gson().toJson(obj)); 
    editor.commit();
}

public static ComplexObject getComplexObject (Context ctx){
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
    String sobj = preferences.getString("COMPLEX_OBJECT", "");
    if(sobj.equals(""))return null;
    else return new Gson().fromJson(sobj, ComplexObject.class);
}

[1] code.google.com/p/google-gson

Answer 9

Para la escritura:

 private <T> void storeData(String key, T data) {
    ByteArrayOutputStream serializedData = new ByteArrayOutputStream();

    try {
        ObjectOutputStream serializer = new ObjectOutputStream(serializedData);
        serializer.writeObject(data);
    } catch (IOException e) {
        e.printStackTrace();
    }

    SharedPreferences sharedPreferences = getSharedPreferences(TAG, 0);
    SharedPreferences.Editor edit = sharedPreferences.edit();

    edit.putString(key, Base64.encodeToString(serializedData.toByteArray(), Base64.DEFAULT));
    edit.commit();
}

Para leer:

private <T> T getStoredData(String key) {
    SharedPreferences sharedPreferences = getSharedPreferences(TAG, 0);
    String serializedData = sharedPreferences.getString(key, null);
    T storedData = null;
    try {
        ByteArrayInputStream input = new ByteArrayInputStream(Base64.decode(serializedData, Base64.DEFAULT));
        ObjectInputStream inputStream = new ObjectInputStream(input);
        storedData = (T)inputStream.readObject();
    } catch (IOException|ClassNotFoundException|java.lang.IllegalArgumentException e) {
        e.printStackTrace();
    }

    return storedData;
}