Enum oder Objekt durch eine Absicht weitergeben (die beste Lösung)

Dies ist eine alte Frage, aber jeder nicht zu erwähnen, dass Enums sind eigentlich Serializable und kann daher perfekt werden Hinzugefügt, um eine Absicht als eine extra. Wie diese:

public enum AwesomeEnum {
  SOMETHING, OTHER;
};

intent.putExtra("AwesomeEnum", AwesomeEnum.SOMETHING);

AwesomeEnum result = (AwesomeEnum) intent.getSerializableExtra("AwesomeEnum");

Den Vorschlag für die Verwendung statischer oder Anwendung breit Variablen ist eine wirklich schlechte Idee. Das ist wirklich Paare, die Ihre Aktivitäten in einen Zustand verwalten von system-und es ist schwer zu warten, zu Debuggen und das problem gebunden.

ALTERNATIVEN:

Einen guten Punkt wurde bereits von tedzyc über die Tatsache, dass die Lösung von Oderik Sie gibt einen Fehler. Aber die alternative ist ein bisschen bröckeln-einige verwenden auch Generika).

Wenn Sie wirklich besorgt über die Leistung der addition der enum-eine Absicht, die ich Vorschlage, diese alternativen statt:

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

Verwendung:

//Sender usage
AwesomeEnum.SOMETHING.attachTo(intent);
//Receiver usage
AwesomeEnum result = AwesomeEnum.detachFrom(intent);

OPTION 2:
(generische, wiederverwendbare und entkoppelt von der 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);
    }
}

Verwendung:

//Sender usage
EnumUtil.serialize(AwesomeEnum.Something).to(intent);
//Receiver usage
AwesomeEnum result = 
EnumUtil.deserialize(AwesomeEnum.class).from(intent);

InformationsquelleAutor der Antwort pablisco

Können Sie übergeben Sie ein enum als string.

public enum CountType {
    ONE,
    TWO,
    THREE
}

private CountType count;
count = ONE;

String countString = count.name();

CountType countToo = CountType.valueOf(countString);

Gegeben strings unterstützt werden, Sie sollten in der Lage sein, um übergeben Sie den Wert des enum-um mit kein problem.

InformationsquelleAutor der Antwort Cameron Lowell Palmer

Wenn Sie wirklich brauchen, um, Sie könnten serialisieren eines enum als String, mit name() und valueOf(String) wie folgt:

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

Dies natürlich nicht funktionieren, wenn Ihre enums mutable Zustand (was Sie nicht sollten, wirklich).

InformationsquelleAutor der Antwort Jan Berkel

über Oderik post:

Können Sie machen Sie Ihre enum-Parcelable implementieren, das ist ziemlich einfach für enums:

public enum MyEnum implements Parcelable {
...
}
Sie kann als Vorsatz.putExtra(String Parcelable).

Wenn Sie definieren eine MyEnum variable myEnum, dann tun Absicht.putExtra("Parcelable1", myEnum), Sie erhalten eine "Die Methode putExtra(String Parcelable) mehrdeutig ist für die Art Absicht" Fehlermeldung.
da gibt es auch ein Vorsatz.putExtra(String Parcelable) - Methode und die ursprüngliche 'Enum' Typ selbst implementiert das Serializable interface, so dass der compiler nicht wissen, wählen Sie, welche Methode(Vorsatz.putExtra(String Parcelable/oder Serializable)).

Schlage vor, entfernen Sie die Parcelable-Schnittstelle von MyEnum, und bewegen Sie den core-code in Wickel-Klasse " Parcelable Umsetzung, wie diese(Father2 ist ein Parcelable und enthalten ein enum-Feld):

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

}

dann können wir tun:

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

InformationsquelleAutor der Antwort tedzyc

Mag ich einfach.

• Der Fred Aktivität hat zwei Modi -- HAPPY und SAD.
• Erstellen Sie eine statische IntentFactory schafft, dass Ihre Intent für Sie. Übergeben Sie das Mode Sie wollen.
• Die IntentFactory verwendet den Namen des Mode Klasse als Namen für das extra.
• Die IntentFactory wandelt die Mode zu einem String mit name()
• Bei der Einreise in die onCreate diese Information nutzen um zu konvertieren zurück zu einem Mode.

• Könnten Sie ordinal() und Mode.values() als gut. Ich mag strings, da kann ich sehen, wie Sie in den debugger.

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

InformationsquelleAutor der Antwort JohnnyLambada

Betrachten Sie Folgende enum ::

public static  enum MyEnum {
    ValueA,
    ValueB
}

Für Die Übergabe ::

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

Abrufen wieder aus der Absicht/bundle/Argumente ::

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

InformationsquelleAutor der Antwort muzz