C'est une vieille question, mais tout le monde ne mentionne pas que les énumérations sont réellement Serializableet peuvent donc parfaitement être ajoutées à une intention en tant que supplément. Comme ça:
public enum AwesomeEnum {
SOMETHING, OTHER;
}
intent.putExtra("AwesomeEnum", AwesomeEnum.SOMETHING);
AwesomeEnum result = (AwesomeEnum) intent.getSerializableExtra("AwesomeEnum");
La suggestion d'utiliser des variables statiques ou à l'échelle de l'application est une très mauvaise idée. Cela couple vraiment vos activités à un système de gestion d'état, et il est difficile à maintenir, à déboguer et à résoudre.
ALTERNATIVES:
Un bon point a été noté par tedzyc sur le fait que la solution fournie par Oderik vous donne une erreur. Cependant, l'alternative proposée est un peu lourde à utiliser (même en utilisant des génériques).
Si vous êtes vraiment préoccupé par les performances de l'ajout de l'énumération à une intention, je propose plutôt ces alternatives:
OPTION 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)];
}
}
Usage:
// Sender usage
AwesomeEnum.SOMETHING.attachTo(intent);
// Receiver usage
AwesomeEnum result = AwesomeEnum.detachFrom(intent);
OPTION 2:
(générique, réutilisable et découplé de l'énumération)
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);
}
}
Usage:
// Sender usage
EnumUtil.serialize(AwesomeEnum.Something).to(intent);
// Receiver usage
AwesomeEnum result =
EnumUtil.deserialize(AwesomeEnum.class).from(intent);
OPTION 3 (avec Kotlin):
Cela fait un moment, mais depuis que nous avons Kotlin, j'ai pensé ajouter une autre option pour le nouveau paradigme. Ici, nous pouvons utiliser des fonctions d'extension et des types réifiés (qui conservent le type lors de la compilation).
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] }
Il y a quelques avantages à le faire de cette façon.
- Nous n'avons pas besoin de la «surcharge» d'un objet intermédiaire pour effectuer la sérialisation car tout est fait sur place grâce à
inlinequoi remplacera les appels par le code à l'intérieur de la fonction.
- Les fonctions sont plus familières car elles sont similaires à celles du SDK.
- L'EDI remplira automatiquement ces fonctions, ce qui signifie qu'il n'est pas nécessaire d'avoir une connaissance préalable de la classe d'utilité.
L'un des inconvénients est que, si nous changeons l'ordre des Emums, toute ancienne référence ne fonctionnera pas. Cela peut être un problème avec des choses comme les intentions dans les intentions en attente car elles peuvent survivre aux mises à jour. Cependant, pour le reste du temps, ça devrait aller.
Il est important de noter que d'autres solutions, comme l'utilisation du nom au lieu de la position, échoueront également si nous renommons l'une des valeurs. Bien que, dans ces cas, nous obtenions une exception au lieu de la valeur Enum incorrecte.
Usage:
// Sender usage
intent.putExtra(AwesomeEnum.SOMETHING)
// Receiver usage
val result = intent.getEnumExtra<AwesomeEnum>()