Esta es una vieja pregunta, pero todos no mencionan que Enums son realmente Serializabley, por lo tanto, se pueden agregar perfectamente a un Intent 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 toda la aplicación es una muy mala idea. Esto realmente combina sus actividades con un sistema de gestión de estado, y es difícil de mantener, depurar y resolver problemas.
ALTERNATIVAS:
Tedzyc señaló un buen punto sobre el hecho de que la solución proporcionada por Oderik le da un error. Sin embargo, la alternativa ofrecida es un poco engorrosa de usar (incluso con genéricos).
Si realmente le preocupa el rendimiento de agregar la enumeración a una intención, le 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);
OPCIÓN 3 (con Kotlin):
Ha pasado un tiempo, pero desde ahora tenemos a Kotlin, pensé que agregaría otra opción para el nuevo paradigma. Aquí podemos hacer uso de funciones de extensión y tipos reified (que retiene el tipo al compilar).
inline fun <reified T : Enum<T>> Intent.putExtra(victim: T): Intent =
putExtra(T::class.java.name, victim.ordinal)
inline fun <reified T: Enum<T>> Intent.getEnumExtra(): T? =
getIntExtra(T::class.java.name, -1)
.takeUnless { it == -1 }
?.let { T::class.java.enumConstants[it] }
Hay algunos beneficios de hacerlo de esta manera.
- No requerimos la "sobrecarga" de un objeto intermediario para realizar la serialización, ya que todo se hace en su lugar gracias a lo
inlinecual reemplazará las llamadas con el código dentro de la función.
- Las funciones son más familiares ya que son similares a las del SDK.
- El IDE completará automáticamente estas funciones, lo que significa que no es necesario tener conocimientos previos de la clase de utilidad.
Una de las desventajas es que, si cambiamos el orden de los Emums, cualquier referencia anterior no funcionará. Esto puede ser un problema con cosas como Intentos dentro de intentos pendientes, ya que pueden sobrevivir a las actualizaciones. Sin embargo, por el resto del tiempo, debería estar bien.
Es importante tener en cuenta que otras soluciones, como usar el nombre en lugar de la posición, también fallarán si cambiamos el nombre de cualquiera de los valores. Aunque, en esos casos, obtenemos una excepción en lugar del valor incorrecto Enum.
Uso:
// Sender usage
intent.putExtra(AwesomeEnum.SOMETHING)
// Receiver usage
val result = intent.getEnumExtra<AwesomeEnum>()