stringdef - enum android tutorial

Pasar enum u objeto a través de un intento(la mejor solución)

Question

Tengo una actividad que cuando se inicia necesita acceso a dos ArrayLists diferentes. Ambas listas son diferentes objetos que he creado yo mismo.

Básicamente, necesito una forma de pasar estos objetos a la actividad desde un Intento. Puedo usar addExtras () pero esto requiere una clase compatible con Parceable. Podría hacer que mis clases pasen a ser serializables pero, como entiendo, esto ralentiza el programa.

¿Cuáles son mis opciones?

¿Puedo pasar un Enum?

Como un aparte: ¿hay alguna forma de pasar parámetros a un Constructor de actividad desde un Intento?

Answer 1

Considera Seguir enum ::

public static  enum MyEnum {
    ValueA,
    ValueB
}

Para pasar ::

 Intent mainIntent = new Intent(this,MyActivity.class);
 mainIntent.putExtra("ENUM_CONST", MyEnum.ValueA);
 this.startActivity(mainIntent);

Para recuperar desde el intento / paquete / argumentos ::

 MyEnum myEnum = (MyEnum) intent.getSerializableExtra("ENUM_CONST");

Answer 2

Creo que su mejor apuesta será convertir esas listas en algo que se pueda dividir en parcelas, como una cadena (¿o un mapa?) Para acceder a la Actividad. Entonces la actividad tendrá que convertirlo nuevamente a una matriz.

Implementar parcelas personalizadas es un dolor en el cuello en mi humilde opinión, así que lo evitaría si es posible.

Answer 3

Es posible hacer que su Enum implemente Serializable, luego puede pasarlo a través del Intent, ya que hay un método para pasarlo como serializable. El consejo de usar int en lugar de enum es falso. Los mensajes se usan para hacer que su código sea más fácil de leer y de mantener. Sería un gran paso hacia atrás en las edades oscuras para no poder usar Enums.

Answer 4

Me gusta simple.

• La actividad de Fred tiene dos modos: HAPPY y SAD .
• Cree una IntentFactory estática que cree su Intent para usted. Pásalo al Mode que quieras.
• IntentFactory usa el nombre de la clase Mode como el nombre del extra.
• IntentFactory convierte el Mode en una String con el name()
• Al ingresar a onCreate use esta información para convertir nuevamente a un Mode .

• También puede usar ordinal() y Mode.values() . Me gustan las cadenas porque puedo verlas en el depurador.

  public class Fred extends Activity {
  
      public static enum Mode {
          HAPPY,
          SAD,
          ;
      }
  
      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.betting);
          Intent intent = getIntent();
          Mode mode = Mode.valueOf(getIntent().getStringExtra(Mode.class.getName()));
          Toast.makeText(this, "mode="+mode.toString(), Toast.LENGTH_LONG).show();
      }
  
      public static Intent IntentFactory(Context context, Mode mode){
          Intent intent = new Intent();
          intent.setClass(context,Fred.class);
          intent.putExtra(Mode.class.getName(),mode.name());
  
          return intent;
      }
  }

Answer 5

No use enumeraciones. Razón # 78 para no usar enumeraciones. :) Usa enteros, que pueden ser remotos fácilmente a través de Bundle y Parcelable.

Answer 6

Para pasar una enumeración por intención, puede convertir enum en entero.

Ex:

public enum Num{A ,B}

Enviando (enum a entero):

Num send = Num.A;
intent.putExtra("TEST", send.ordinal());

Recibiendo (entero a enum):

Num rev;
int temp = intent.getIntExtra("TEST", -1);
if(temp >= 0 && temp < Num.values().length)
    rev = Num.values()[temp];

Atentamente. :)

Answer 7

Puede pasar una enumeración como una cadena.

public enum CountType {
    ONE,
    TWO,
    THREE
}

private CountType count;
count = ONE;

String countString = count.name();

CountType countToo = CountType.valueOf(countString);

Dado que se admiten cadenas de caracteres, debería poder pasar el valor de la enumeración sin problema.

Answer 8

Puedes hacer que tu enum implemente Parcelable, lo cual es bastante fácil para las enumeraciones:

public enum MyEnum implements Parcelable {
    VALUE;


    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(final Parcel dest, final int flags) {
        dest.writeInt(ordinal());
    }

    public static final Creator<MyEnum> CREATOR = new Creator<MyEnum>() {
        @Override
        public MyEnum createFromParcel(final Parcel source) {
            return MyEnum.values()[source.readInt()];
        }

        @Override
        public MyEnum[] newArray(final int size) {
            return new MyEnum[size];
        }
    };
}

Luego puede usar Intent.putExtra (String, Parcelable).

ACTUALIZACIÓN: tenga en cuenta el comentario de enum.values() que enum.values() asigna una nueva matriz en cada llamada.

Answer 9

Puedes usar el constructor enum para que enum tenga un tipo de datos primitivo.

public enum DaysOfWeek {
    MONDAY(1),
    TUESDAY(2),
    WEDNESDAY(3),
    THURSDAY(4),
    FRIDAY(5),
    SATURDAY(6),
    SUNDAY(7);

    private int value;
    private DaysOfWeek(int value) {
        this.value = value;
    }

    public int getValue() {
        return this.value;
    }

    private static final SparseArray<DaysOfWeek> map = new SparseArray<DaysOfWeek>();

    static
    {
         for (DaysOfWeek daysOfWeek : DaysOfWeek.values())
              map.put(daysOfWeek.value, daysOfWeek);
    }

    public static DaysOfWeek from(int value) {
        return map.get(value);
    }
}

puede usar para pasar int como extras y luego extraerlo de enum usando su valor.

Answer 10

Si realmente lo necesita, puede serializar una enumeración como una Cadena, utilizando name() y valueOf(String) , de la siguiente manera:

 class Example implements Parcelable { 
   public enum Foo { BAR, BAZ }

   public Foo fooValue;

   public void writeToParcel(Parcel dest, int flags) {
      parcel.writeString(fooValue == null ? null : fooValue.name());
   }

   public static final Creator<Example> CREATOR = new Creator<Example>() {
     public Example createFromParcel(Parcel source) {        
       Example e = new Example();
       String s = source.readString(); 
       if (s != null) e.fooValue = Foo.valueOf(s);
       return e;
     }
   }
 }

Obviamente, esto no funciona si tus enumeraciones tienen estado mutable (que no deberían, en realidad).

Answer 11

sobre la publicación de Oderik:

Puedes hacer que tu enum implemente Parcelable, lo cual es bastante fácil para las enumeraciones:

public enum MyEnum implementa Parcelable {...} Puedes usar Intent.putExtra (String, Parcelable).

Si define una variable MyEnum myEnum, entonces intent.putExtra ("Parcelable1", myEnum), obtendrá un mensaje de error "El método putExtra (String, Parcelable) es ambiguo para el tipo Intent". porque también hay un método Intent.putExtra (String, Parcelable) y el tipo ''Enum'' original implementa la interfaz Serializable, por lo que el compilador no sabe qué método elegir (intent.putExtra (String, Parcelable / o Serializable)).

Sugiera que elimine la interfaz Parcelable de MyEnum y mueva el código del núcleo a la implementación parcelable de la clase wrap, así (Father2 es Parcelable y contiene un campo enum):

public class Father2 implements Parcelable {

AnotherEnum mAnotherEnum;
int mField;

public Father2(AnotherEnum myEnum, int field) {
    mAnotherEnum = myEnum;
    mField = field;
}

private Father2(Parcel in) {
    mField = in.readInt();
    mAnotherEnum = AnotherEnum.values()[in.readInt()];
}

public static final Parcelable.Creator<Father2> CREATOR = new Parcelable.Creator<Father2>() {

    public Father2 createFromParcel(Parcel in) {
        return new Father2(in);
    }

    @Override
    public Father2[] newArray(int size) {
        return new Father2[size];
    }

};

@Override
public int describeContents() {
    return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
    dest.writeInt(mField);
    dest.writeInt(mAnotherEnum.ordinal());
}

}

entonces podemos hacer:

AnotherEnum anotherEnum = AnotherEnum.Z;
intent.putExtra("Serializable2", AnotherEnum.X);   
intent.putExtra("Parcelable2", new Father2(AnotherEnum.X, 7));

Answer 12

Esta es una vieja pregunta, pero todos no mencionan que los Enums son en realidad Serializable y, por lo tanto, se pueden agregar perfectamente a un Intento como extra. Me gusta esto:

public enum AwesomeEnum {
  SOMETHING, OTHER;
};

intent.putExtra("AwesomeEnum", AwesomeEnum.SOMETHING);

AwesomeEnum result = (AwesomeEnum) intent.getSerializableExtra("AwesomeEnum");

La sugerencia de usar variables estáticas o de aplicación amplia es una muy mala idea. Esto realmente combina sus actividades con un sistema de administración de estado y es difícil de mantener, depurar y resolver problemas.

ALTERNATIVAS:

Un buen punto fue observado por tedzyc sobre el hecho de que la solución provista por Oderik le da un error. Sin embargo, la alternativa provista es un poco desmoronada, algo para usar (incluso usando genéricos).

Si realmente te preocupa el rendimiento de agregar la enumeración a un intento, propongo estas alternativas:

OPCIÓN 1:

public enum AwesomeEnum {
  SOMETHING, OTHER;
  private static final String name = AwesomeEnum.class.getName();
  public void attachTo(Intent intent) {
    intent.putExtra(name, ordinal());
  }
  public static AwesomeEnum detachFrom(Intent intent) {
    if(!intent.hasExtra(name)) throw new IllegalStateException();
    return values()[intent.getIntExtra(name, -1)];
  }
}

Uso:

// Sender usage
AwesomeEnum.SOMETHING.attachTo(intent);
// Receiver usage
AwesomeEnum result = AwesomeEnum.detachFrom(intent);

OPCIÓN 2: (genérico, reutilizable y desacoplado de la enumeración)

public final class EnumUtil {
    public static class Serializer<T extends Enum<T>> extends Deserializer<T> {
        private T victim;
        @SuppressWarnings("unchecked") 
        public Serializer(T victim) {
            super((Class<T>) victim.getClass());
            this.victim = victim;
        }
        public void to(Intent intent) {
            intent.putExtra(name, victim.ordinal());
        }
    }
    public static class Deserializer<T extends Enum<T>> {
        protected Class<T> victimType;
        protected String name;
        public Deserializer(Class<T> victimType) {
            this.victimType = victimType;
            this.name = victimType.getName();
        }
        public T from(Intent intent) {
            if (!intent.hasExtra(name)) throw new IllegalStateException();
            return victimType.getEnumConstants()[intent.getIntExtra(name, -1)];
        }
    }
    public static <T extends Enum<T>> Deserializer<T> deserialize(Class<T> victim) {
        return new Deserializer<T>(victim);
    }
    public static <T extends Enum<T>> Serializer<T> serialize(T victim) {
        return new Serializer<T>(victim);
    }
}

Uso:

// Sender usage
EnumUtil.serialize(AwesomeEnum.Something).to(intent);
// Receiver usage
AwesomeEnum result = 
EnumUtil.deserialize(AwesomeEnum.class).from(intent);