Questa è una vecchia domanda, ma tutti non menzionano che gli Enum sono in realtà Serializablee quindi possono essere perfettamente aggiunti a un Intento come extra. Come questo:
public enum AwesomeEnum {
SOMETHING, OTHER;
}
intent.putExtra("AwesomeEnum", AwesomeEnum.SOMETHING);
AwesomeEnum result = (AwesomeEnum) intent.getSerializableExtra("AwesomeEnum");
Il suggerimento di utilizzare variabili statiche o a livello di applicazione è una pessima idea. Questo abbina davvero le tue attività a un sistema di gestione statale ed è difficile da mantenere, eseguire il debug e limitare i problemi.
ALTERNATIVE:
Tedzyc ha sottolineato un buon punto sul fatto che la soluzione fornita da Oderik ti dà un errore. Tuttavia, l'alternativa offerta è un po 'ingombrante da usare (anche usando i generici).
Se sei davvero preoccupato per la prestazione di aggiungere l'enum a un Intento, propongo invece queste alternative:
OPZIONE 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);
OPZIONE 2:
(generico, riutilizzabile e disaccoppiato dall'enum)
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);
OPZIONE 3 (con Kotlin):
È passato un po 'di tempo, ma da allora abbiamo Kotlin, ho pensato di aggiungere un'altra opzione per il nuovo paradigma. Qui possiamo fare uso delle funzioni di estensione e dei tipi reificati (che conserva il tipo durante la compilazione).
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] }
Ci sono alcuni vantaggi nel farlo in questo modo.
- Non è necessario il "sovraccarico" di un oggetto intermedio per eseguire la serializzazione poiché è tutto realizzato sul posto grazie al
inlinequale sostituirà le chiamate con il codice all'interno della funzione.
- Le funzioni sono più familiari in quanto simili a quelle dell'SDK.
- L'IDE completerà automaticamente queste funzioni, il che significa che non è necessario avere una conoscenza precedente della classe di utilità.
Uno degli aspetti negativi è che, se cambiamo l'ordine degli Emum, qualsiasi vecchio riferimento non funzionerà. Questo può essere un problema con cose come gli Intenti all'interno di quelli in sospeso in quanto potrebbero sopravvivere agli aggiornamenti. Tuttavia, per il resto del tempo, dovrebbe essere ok.
È importante notare che anche altre soluzioni, come l'utilizzo del nome anziché della posizione, falliranno se rinominiamo uno dei valori. Sebbene, in quei casi, otteniamo un'eccezione invece del valore Enum errato.
Uso:
// Sender usage
intent.putExtra(AwesomeEnum.SOMETHING)
// Receiver usage
val result = intent.getEnumExtra<AwesomeEnum>()