Passagem de enum ou objeto através de uma intenção (a melhor solução)

Eu tenho uma atividade que, quando iniciada, precisa acessar duas ArrayLists diferentes. Ambas as listas são objetos diferentes que eu mesmo criei.

Basicamente, preciso de uma maneira de passar esses objetos para a atividade a partir de um Intent. Eu posso usar addExtras (), mas isso requer uma classe compatível com Parceable. Eu poderia fazer minhas aulas serem passadas serializáveis, mas, pelo que entendi, isso atrasa o programa.

Quais são as minhas opções?

Posso passar um Enum?

Como um aparte: existe uma maneira de passar parâmetros para um Construtor de Atividades a partir de uma Intenção?

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>()

Você pode fazer seu enum implementar Parcelable, o que é bastante fácil para enumerações:

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];
        }
    };
}

Você pode usar Intent.putExtra (String, Parcelable).

ATUALIZAÇÃO: Observe o comentário de wreckgar que enum.values()aloca uma nova matriz a cada chamada.

ATUALIZAÇÃO: o Android Studio possui um modelo ativo ParcelableEnumque implementa esta solução. (No Windows, use Ctrl+ J)

Você pode passar um enum como uma string.

public enum CountType {
    ONE,
    TWO,
    THREE
}

private CountType count;
count = ONE;

String countString = count.name();

CountType countToo = CountType.valueOf(countString);

Dadas seqüências de caracteres são suportadas, você deve ser capaz de passar o valor do enum sem nenhum problema.

Para passar uma enum por intenção, você pode converter enum em número inteiro.

Ex:

public enum Num{A ,B}

Enviando (enum para inteiro):

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

Recebendo (inteiro para enum):

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

Cumprimentos. :)

Se você realmente precisar, pode serializar uma enumeração como uma String, usando name()e valueOf(String), da seguinte maneira:

 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, isso não funciona se seus enums tiverem um estado mutável (o que não deveriam, na verdade).

Pode ser possível fazer seu Enum implementar Serializable, então você pode passá-lo através do Intent, pois existe um método para transmiti-lo como serializável. O conselho para usar int em vez de enum é falso. As enums são usadas para facilitar a leitura e a manutenção do código. Seria um grande passo para trás na idade das trevas para não poder usar Enums.

sobre a publicação de Oderik:

Você pode fazer seu enum implementar Parcelable, o que é bastante fácil para enumerações:

enumeração pública MyEnum implementa Parcelable {...} Você pode usar Intent.putExtra (String, Parcelable).

Se você definir uma variável MyEnum myEnum, faça intent.putExtra ("Parcelable1", myEnum), você receberá uma mensagem de erro "O método putExtra (String, Parcelable) é ambíguo para o tipo Intent". porque também existe um método Intent.putExtra (String, Parcelable) e o próprio tipo 'Enum' implementa a interface Serializable, portanto, o compilador não sabe escolher qual método (intent.putExtra (String, Parcelable / ou Serializable)).

Sugira que remova a interface Parcelable do MyEnum e mova o código principal para a implementação Parcelable da classe wrap, como esta (o Father2 é um Parcelable e contém um 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());
}

}

então nós podemos fazer:

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

você pode usar o construtor enum para que o enum tenha um tipo de dados 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);
    }
}

você pode usar para passar int como extras e retirá-lo do enum usando seu valor.

A maioria das respostas que estão usando o conceito Parcelable aqui está em código Java. É mais fácil fazê-lo no Kotlin.

Apenas anote sua classe enum com @Parcelize e implemente a interface Parcelable.

@Parcelize
enum class ViewTypes : Parcelable {
TITLE, PRICES, COLORS, SIZES
}

Eu gosto de simples

• A atividade de Fred tem dois modos - HAPPYe SAD.
• Crie uma estática IntentFactoryque crie o seu Intentpara você. Passe o Modeque quiser.
• O IntentFactoryusa o nome da Modeclasse como o nome do extra.
• O IntentFactoryconverte Modepara um Stringusandoname()
• Após a entrada em onCreateuso, essas informações serão convertidas novamente em a Mode.

• Você poderia usar ordinal()e Mode.values()também. Eu gosto de strings porque posso vê-las no 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;
      }
  }

Acho que sua melhor aposta será converter essas listas em algo que pode ser parcelado, como uma string (ou mapa?) Para levá-la à Atividade. Então a Atividade precisará convertê-lo novamente em uma matriz.

Implementar encomendas personalizadas é uma dor no pescoço IMHO, então eu evitaria se possível.

Considere a seguir enum ::

public static  enum MyEnum {
    ValueA,
    ValueB
}

Para passar ::

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

Para recuperar de volta a intenção / pacote configurável / argumentos:

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

Se você apenas deseja enviar uma enumeração, pode fazer algo como:

Primeiro, declare uma enum contendo algum valor (que pode ser passado através da intenção):

 public enum MyEnum {
    ENUM_ZERO(0),
    ENUM_ONE(1),
    ENUM_TWO(2),
    ENUM_THREE(3);
    private int intValue;

    MyEnum(int intValue) {
        this.intValue = intValue;
    }

    public int getIntValue() {
        return intValue;
    }

    public static MyEnum getEnumByValue(int intValue) {
        switch (intValue) {
            case 0:
                return ENUM_ZERO;
            case 1:
                return ENUM_ONE;
            case 2:
                return ENUM_TWO;
            case 3:
                return ENUM_THREE;
            default:
                return null;
        }
    }
}

Então:

  intent.putExtra("EnumValue", MyEnum.ENUM_THREE.getIntValue());

E quando você quiser obtê-lo:

  NotificationController.MyEnum myEnum = NotificationController.MyEnum.getEnumByValue(intent.getIntExtra("EnumValue",-1);

Pedaco de bolo!

Use as funções de extensão Kotlin

inline fun <reified T : Enum<T>> Intent.putExtra(enumVal: T, key: String? = T::class.qualifiedName): Intent =
    putExtra(key, enumVal.ordinal)

inline fun <reified T: Enum<T>> Intent.getEnumExtra(key: String? = T::class.qualifiedName): T? =
    getIntExtra(key, -1)
        .takeUnless { it == -1 }
        ?.let { T::class.java.enumConstants[it] }

Isso oferece a flexibilidade de passar vários do mesmo tipo de enumeração ou usar como padrão o nome da classe.

// Add to gradle
implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

// Import the extension functions
import path.to.my.kotlin.script.putExtra
import path.to.my.kotlin.script.getEnumExtra

// To Send
intent.putExtra(MyEnumClass.VALUE)

// To Receive
val result = intent.getEnumExtra<MyEnumClass>()

Não use enums. Razão # 78 para não usar enumerações. :) Use números inteiros, que podem ser facilmente remotos através de Bundle e Parcelable.