Esta é uma pergunta antiga, mas todo mundo deixa de mencionar que as Enums são realmente Serializablee, portanto, podem ser adicionadas perfeitamente a uma Intenção como um extra. Como isso:
public enum AwesomeEnum {
SOMETHING, OTHER;
}
intent.putExtra("AwesomeEnum", AwesomeEnum.SOMETHING);
AwesomeEnum result = (AwesomeEnum) intent.getSerializableExtra("AwesomeEnum");
A sugestão de usar variáveis estáticas ou de todo o aplicativo é uma péssima idéia. Isso realmente associa suas atividades a um sistema de gerenciamento de estado e é difícil manter, depurar e vincular problemas.
ALTERNATIVAS:
Um bom ponto foi observado por tedzyc sobre o fato de que a solução fornecida pela Oderik gera um erro. No entanto, a alternativa oferecida é um pouco complicada de usar (mesmo usando genéricos).
Se você está realmente preocupado com o desempenho de adicionar a enum a uma intenção, proponho essas alternativas:
OPÇÃO 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);
OPÇÃO 2:
(genérica, reutilizável e dissociada da enumeração)
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);
OPÇÃO 3 (com Kotlin):
Já faz um tempo, mas como agora temos o Kotlin, pensei em adicionar outra opção para o novo paradigma. Aqui, podemos usar funções de extensão e tipos reificados (que mantêm o tipo ao 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] }
Existem alguns benefícios em fazê-lo dessa maneira.
- Não exigimos que a "sobrecarga" de um objeto intermediário faça a serialização, pois tudo é feito no local, graças ao
inlinequal substituirá as chamadas pelo código dentro da função.
- As funções são mais familiares, pois são semelhantes às do SDK.
- O IDE completará automaticamente essas funções, o que significa que não há necessidade de ter conhecimento prévio da classe de utilitário.
Uma das desvantagens é que, se mudarmos a ordem dos Emums, qualquer referência antiga não funcionará. Isso pode ser um problema com coisas como Intents dentro de intenções pendentes, pois elas podem sobreviver a atualizações. No entanto, pelo resto do tempo, deve estar ok.
É importante observar que outras soluções, como usar o nome em vez da posição, também falharão se renomearmos qualquer um dos valores. Embora, nesses casos, recebamos uma exceção em vez do valor incorreto do Enum.
Uso:
// Sender usage
intent.putExtra(AwesomeEnum.SOMETHING)
// Receiver usage
val result = intent.getEnumExtra<AwesomeEnum>()