Übergabe von Enum oder Objekt durch einen Intent (die beste Lösung)

Question

Ich habe eine Aktivität, die beim Start Zugriff auf zwei verschiedene ArrayLists benötigt. Beide Listen sind unterschiedliche Objekte, die ich selbst erstellt habe.

Grundsätzlich benötige ich eine Möglichkeit, diese Objekte von einem Intent an die Aktivität zu übergeben. Ich kann addExtras() verwenden, aber dies erfordert eine Parceable kompatible Klasse. Ich könnte meine Klassen zu serializable übergeben werden, aber wie ich verstehe, verlangsamt dies das Programm.

Welche Möglichkeiten habe ich?

Kann ich eine Enum übergeben?

Nebenbei bemerkt: Gibt es eine Möglichkeit, Parameter an einen Activity Constructor aus einem Intent zu übergeben?

Answer 1

Es kann möglich sein, Ihre Enum implementieren Serializable dann können Sie es über das Intent übergeben, wie es eine Methode für die Übergabe als serializable ist. Der Rat, int anstelle von enum zu verwenden, ist falsch. Enums werden verwendet, um Ihren Code leichter lesbar und einfacher zu pflegen zu machen. Es wäre ein großer Rückschritt in das finstere Mittelalter, Enums nicht verwenden zu können.

Answer 2

Die meisten Antworten, die hier das Parcelable-Konzept verwenden, sind in Java-Code. Es ist einfacher, dies in Kotlin zu tun.

Beschriften Sie Ihre Enum-Klasse einfach mit @Parcelize und implementieren die Schnittstelle Parcelable.

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

Answer 3

Zu Oderiks Beitrag:

Sie können Ihre enum implementieren Parcelable, die ganz einfach für enums ist:

public enum MyEnum implements Parcelable { ... } Sie können dann Intent.putExtra(String, Parcelable) verwenden.

Wenn Sie eine MyEnum-Variable myEnum definieren und dann intent.putExtra("Parcelable1", myEnum) ausführen, erhalten Sie die Fehlermeldung "The method putExtra(String, Parcelable) is ambiguous for the type Intent". weil es auch eine Methode Intent.putExtra(String, Parcelable) gibt, und der ursprüngliche Typ 'Enum' selbst die Schnittstelle Serializable implementiert, so dass der Compiler nicht weiß, welche Methode er wählen soll (intent.putExtra(String, Parcelable/or Serializable)).

Schlagen Sie vor, die Schnittstelle Parcelable aus MyEnum zu entfernen und den Kerncode in die Parcelable-Implementierung der Wrap-Klasse zu verschieben, etwa so (Father2 ist ein Parcelable und enthält 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 das tun:

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

Answer 4

Sie können den enum-Konstruktor für enum verwenden, um einen primitiven Datentyp zu haben.

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

können Sie verwenden, um int als Extras übergeben dann ziehen Sie es aus enum mit seinem Wert.

Answer 5

Ich mag es einfach.

• Die Fred-Aktivität hat zwei Modi. HAPPY y SAD .
• Erstellen Sie eine statische IntentFactory die Ihr Intent für Sie. Übergeben Sie es dem Mode Sie wollen.
• En IntentFactory verwendet den Namen des Mode Klasse als Name für das Extra.
• En IntentFactory wandelt die Mode zu einer String mit name()
• Bei Eintritt in onCreate diese Information verwenden, um wieder in eine Mode .

• Sie könnten verwenden ordinal() y Mode.values() auch. Ich mag Strings, weil ich sie im Debugger sehen kann.

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