Android – Ist es ok, @IntDef Werte innerhalb @interface zu setzen?

Ich versuche, @IntDef Annotation in Android Entwicklung zu implementieren.

Erste Methode : Es sieht gut aus mit der Definition getrennt in einer Constant.java Klasse:

  • Crop Video vor der Codierung mit MediaCodec für Grafikas "Continuous Capture" Aktivität
  • Unit-Test mit Android-Volleyball
  • Wie schalte ich Konten unter der neuen Google Drive Android API ein
  • PercentRelativeLayout, wie man die Höhe programmgesteuert festlegt
  • Portrait für Telefon, Landschaft für Tablet (Android-Layout)
  • Wie man BENUTZER INAKTIVITÄT in android erkennt
  •  public class Constant { @IntDef(value={SORT_PRICE, SORT_TIME, SORT_DURATION}) @Retention(RetentionPolicy.SOURCE) public @interface SortType{} public static final int SORT_PRICE = 0; public static final int SORT_TIME = 1; public static final int SORT_DURATION = 2; } 

    Verwendung:

     @Constant.SortType int sortType = Constant.SORT_PRICE; 

    Aber die Dinge werden viel mühevoller, wenn es mehrere Definition (zB UserType, StoreType, etc.) in einer Datei gibt.

    Zweite Methode: So kam ich mit so etwas, um Werte zwischen Definition zu trennen:

     public class Constant { @IntDef(value={SortType.SORT_PRICE, SortType.SORT_TIME, SortType.SORT_DURATION}) @Retention(RetentionPolicy.SOURCE) public @interface SortTypeDef{} public static class SortType{ public static final int PRICE = 0; public static final int TIME = 1; public static final int DURATION = 2; } } 

    Verwendung:

     @Constant.SortTypeDef int sortType = Constant.SortType.PRICE; 

    Aber wie Sie sehen können, habe ich zwei verschiedene Namen dafür erstellt: SortTypeDef und SortType

    Dritte Methode: Ich habe versucht, die Liste der möglichen Werte innerhalb @interface :

     public class Constant { @IntDef(value={SortType.SORT_PRICE, SortType.SORT_TIME, SortType.SORT_DURATION}) @Retention(RetentionPolicy.SOURCE) public @interface SortType{ int PRICE = 0; int TIME = 1; int DURATION = 2; } } 

    Verwendung

     @Constant.SortType int sortType = Constant.SortType.PRICE; 

    Während es funktioniert, weiß ich nicht was ist der Nachteil. Ist es in Ordnung, die möglichen Werte von @IntDef in @interface ? Gibt es Leistungsunterschiede zwischen den drei oben genannten Methoden?

  • Wie kann ich einen QR-Code für eine Android-Anwendung generieren?
  • Verwenden Sie vordefinierte Datenbanken mit Realm
  • APN, GCM (FCM): Wie fügt man Rich Media zu Benachrichtigungen hinzu?
  • Usb tether und debug zur gleichen Zeit
  • Wann sollte super.onResume () angerufen werden?
  • Wie entferne ich unbenutzte Ressourcen aus Drittanbieter-Bibliotheken, die ich auf Android aufgenommen habe?
  • 4 Solutions collect form web for “Android – Ist es ok, @IntDef Werte innerhalb @interface zu setzen?”

    Ich kam hier in der Hoffnung zu finden, warum die Android-Dokumente zeigen Ihre erste Methode, aber die dritte Methode hat sich gut für mich in der Produktion Code für Monate gearbeitet. Ich habe keinen Grund gesehen, es nicht so zu machen. Wie du gesagt hast, reinigt es den Namespace, wenn du mehrere Sätze von verwandten Konstanten haben kannst.

    Um deine dritte Methode zu arbeiten, solltest du values wie in der Schnittstelle benennen. Ich habe deinen Code benutzt und es funktioniert:

     public class Constant { @IntDef(value = {SortType.PRICE, SortType.TIME, SortType.DURATION}) @Retention(RetentionPolicy.SOURCE) @interface SortType { int PRICE = 0; int TIME = 1; int DURATION = 2; } } 

    Oder

     public class Constant { @IntDef(value = {SortType.SORT_PRICE, SortType.SORT_TIME, SortType.SORT_DURATION}) @Retention(RetentionPolicy.SOURCE) @interface SortType { int SORT_PRICE = 0; int SORT_TIME = 1; int SORT_DURATION = 2; } } 

    Verwendung für Sekunde:

     @Constant.SortType int sortType = Constant.SortType.SORT_DURATION; 

    Wähle einen, beide sollen arbeiten.

    Kurze Antwort : Für einfache Projekte ist es ok, aber für komplexere ist die erste Methode bevorzugt.

    Lange Antwort : Obwohl der Bytecode für sortType in allen drei Fällen identisch ist, gibt es einen Unterschied. Der Schlüssel liegt in der Retention Annotation, die die Aufbewahrungspolitik auf SOURCE . Das bedeutet, dass Ihre SortType Annotation " vom Compiler verworfen " wird, also wird Bytecode für Annotation selbst nicht generiert.

    Die erste Methode definiert regelmäßige statische Felder außerhalb der Annotationen, wobei der reguläre Bytecode für sie erzeugt wird. Zweite und dritte Fälle definieren Konstanten innerhalb von Annotationen, und ein Bytecode für die Konstanten wird nicht erzeugt.

    Wenn der Compiler Zugriff auf die Quelldatei hat, die Ihre SortType Deklaration enthält, ist jede Methode gut und der Bytecode für sortType ist identisch. Wenn aber Quellcode nicht zugänglich ist (zB haben Sie nur die Bibliothek kompiliert), ist die Annotation nicht zugänglich. Für den ersten Ansatz ist nur die Annotation selbst nicht zugänglich, aber für die letzteren sind auch Konstantenwerte nicht zugänglich.

    Ich habe die dritte Methode als die meisten sauber und strukturiert. Ich habe bis zu einem Tag ein Problem gemacht: Als ich mit dem Schreiben von Espresso-Tests für diesen Code begann, hatte der Compiler keinen Zugriff auf den Quellcode, der die Annotation definiert. Ich musste entweder auf die kanonische IntDef Deklaration IntDef oder ganzzahlige Werte anstelle von symbolischen Konstanten für den Test verwenden.

    Also die untere Zeile ist:

    • Haften an der kanonischen Weise, es sei denn, Ihre Annotation ist intern in Ihrem Code und Sie beziehen sich nicht darauf von irgendwo anders, einschließlich Tests

    Scheint wie ein guter Ort für ein Emum …

    Public enum SortEnum {DAUER, PREIS, ZEIT; }

    Das Android ist ein Google Android Fan-Website, Alles ├╝ber Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.