Layouts und Bindungsausdrücke

Mit der Ausdruckssprache können Sie Ausdrücke schreiben, die ausgelöste Ereignisse verarbeiten nach Aufrufen. Die Datenbindungsbibliothek generiert automatisch die erforderlichen Klassen. um die Ansichten im Layout mit Ihren Datenobjekten zu binden.

Layoutdateien für die Datenbindung weichen ein wenig ab und beginnen mit dem Stamm-Tag layout, gefolgt von einem data-Element und einem view-Stammelement. Diese Ansicht ist das Stammelement in einer nicht bindenden Layoutdatei. Der folgende Code zeigt ein Beispiel für eine Layoutdatei:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
   <data>
       <variable name="user" type="com.example.User"/>
   </data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.firstName}"/>
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.lastName}"/>
   </LinearLayout>
</layout>

Die Variable user in data beschreibt eine Eigenschaft, die in dieses Layout:

<variable name="user" type="com.example.User" />

Ausdrücke im Layout werden in den Attributeigenschaften mithilfe der @{}-Syntax. Im folgenden Beispiel TextView-Text ist festgelegt auf firstName-Eigenschaft der Variable user:

<TextView android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@{user.firstName}" />

Datenobjekte

Angenommen, Sie haben ein einfaches Objekt, um die Entität User zu beschreiben:

data class User(val firstName: String, val lastName: String)

public class User {
  public final String firstName;
  public final String lastName;
  public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
  }
}

Bei diesem Objekttyp ändern sich die Daten nie. In Apps ist es üblich, die einmal gelesen werden und sich danach nie ändern. Es ist auch möglich, Ein Objekt, das einer Reihe von Konventionen folgt, z. B. die Verwendung von Zugriffsmethoden in der Programmiersprache Java, wie im folgenden Beispiel gezeigt:

// Not applicable in Kotlin.
data class User(val firstName: String, val lastName: String)

public class User {
  private final String firstName;
  private final String lastName;
  public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
  }
  public String getFirstName() {
      return this.firstName;
  }
  public String getLastName() {
      return this.lastName;
  }
}

Aus Sicht der Datenbindung sind diese beiden Klassen äquivalent. Die Ausdruck @{user.firstName}, der für den android:text -Attribut auf das Feld firstName in der vorherigen Klasse und im getFirstName()-Methode in der letzten Klasse. Außerdem wurde beschlossen, firstName(), wenn diese Methode vorhanden ist.

Daten binden

Für jede Layoutdatei wird eine Bindungsklasse generiert. Standardmäßig wird der Name des basiert auf dem Namen der Layoutdatei, konvertiert in die Pascal-Schreibweise, wobei das Suffix Binding. Der vorherige Layout-Dateiname ist beispielsweise activity_main.xml, sodass die entsprechende generierte Bindungsklasse ActivityMainBinding.

Diese Klasse enthält alle Bindungen aus den Layouteigenschaften, z. B. die Variable user zu den Layout-Ansichten und weiß, wie Werte zugewiesen werden für die Bindungsausdrücke. Wir empfehlen, die Bindungen beim Aufblähen zu erstellen das Layout, wie im folgenden Beispiel gezeigt:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val binding: ActivityMainBinding = DataBindingUtil.setContentView(
            this, R.layout.activity_main)

    binding.user = User("Test", "User")
}

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
   User user = new User("Test", "User");
   binding.setUser(user);
}

Zur Laufzeit zeigt die App den Nutzer Test in der Benutzeroberfläche an. Alternativ können Sie die Ansicht mithilfe eines LayoutInflater, wie in den folgendes Beispiel:

val binding: ActivityMainBinding = ActivityMainBinding.inflate(getLayoutInflater())

ActivityMainBinding binding = ActivityMainBinding.inflate(getLayoutInflater());

Wenn Sie Datenbindungselemente in einer Fragment, ListView oder RecyclerView können Sie den Adapter verwenden, inflate(). der Binding-Klassen oder der Klasse DataBindingUtil, wie wie im folgenden Codebeispiel gezeigt:

val listItemBinding = ListItemBinding.inflate(layoutInflater, viewGroup, false)
// or
val listItemBinding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false)

ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false);
// or
ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);

Ausdruckssprache

Gemeinsame Funktionen

Die Sprache für Ausdrücke ähnelt sehr vielen Ausdrücken, die in verwaltetem Code zu finden sind. Ich können die folgenden Operatoren und Schlüsselwörter in der Ausdruckssprache verwenden:

• Mathematische Daten: + - / * %
• Stringverkettung: +
• Logisch: && ||
• Binär: & | ^
• Unär: + - ! ~
• Umschalttaste: >> >>> <<
• Vergleich: == > < >= <= (< muss als < maskiert werden)
• instanceof
• Gruppieren: ()
• Literale, z. B. Zeichen, String, numerisch oder null
• Streamen
• Methodenaufrufe
• Feldzugriff
• Arrayzugriff: []
• Ternärer Operator: ?:

Hier einige Beispiele:

android:text="@{String.valueOf(index + 1)}"
android:visibility="@{age > 13 ? View.GONE : View.VISIBLE}"
android:transitionName='@{"image_" + id}'

Fehlende Vorgänge

Die folgenden Vorgänge fehlen in der Ausdruckssyntax, die Sie verwenden können im verwalteten Code:

• this
• super
• new
• Expliziter generischer Aufruf

Operator für Null-Koalescing

Mit dem Null-Koalescing-Operator (??) wird der linke Operand ausgewählt, wenn er nicht null ist. oder das Recht, wenn erstes null ist:

android:text="@{user.displayName ?? user.lastName}"

Funktional entspricht dies Folgendem:

android:text="@{user.displayName != null ? user.displayName : user.lastName}"

Property-Referenzen

Ein Ausdruck kann auf eine Eigenschaft in einer Klasse verweisen, indem er das folgende Format verwendet: Dies ist für Felder, Getter und ObservableField Objekte:

android:text="@{user.lastName}"

Nullzeigerausnahmen vermeiden

Der generierte Datenbindungscode prüft automatisch auf null-Werte und vermeidet, Nullzeigerausnahmen. Beispiel: Im Ausdruck @{user.name} gilt: user ist null und user.name wird der Standardwert null zugewiesen. Wenn Sie Verweisen Sie auf user.age, wobei das Alter vom Typ int ist, dann verwendet die Datenbindung die Standardwert 0.

Referenzen ansehen

Ein Ausdruck kann anhand der ID auf andere Ansichten im Layout verweisen, indem er Folgendes verwendet: Syntax:

android:text="@{exampleText.text}"

Im folgenden Beispiel verweist die Ansicht TextView auf eine EditText-Ansicht in dasselbe Layout:

<EditText
    android:id="@+id/example_text"
    android:layout_height="wrap_content"
    android:layout_width="match_parent"/>
<TextView
    android:id="@+id/example_output"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@{exampleText.text}"/>

Sammlungen

Sie können auf allgemeine Sammlungen wie Arrays, Listen, dünnbesetzte Listen und der Einfachheit halber den Operator [].

<data>
    <import type="android.util.SparseArray"/>
    <import type="java.util.Map"/>
    <import type="java.util.List"/>
    <variable name="list" type="List&lt;String>"/>
    <variable name="sparse" type="SparseArray&lt;String>"/>
    <variable name="map" type="Map&lt;String, String>"/>
    <variable name="index" type="int"/>
    <variable name="key" type="String"/>
</data>
...
android:text="@{list[index]}"
...
android:text="@{sparse[index]}"
...
android:text="@{map[key]}"

Sie können auch mit der object.key-Notation auf einen Wert in der Karte verweisen. Für können Sie @{map[key]} im vorherigen Beispiel durch @{map.key}.

Stringliterale

Sie können den Attributwert in einfache Anführungszeichen setzen. Dadurch können Sie doppelte Anführungszeichen im Ausdruck, wie im folgenden Beispiel gezeigt:

android:text='@{map["firstName"]}'

Sie können den Attributwert auch in doppelte Anführungszeichen setzen. Wenn Sie dies tun, Stringliterale müssen wie gezeigt von Gravis ` umgeben sein. hier:

android:text="@{map[`firstName`]}"

Ressourcen

Ein Ausdruck kann mit der folgenden Syntax auf Anwendungsressourcen verweisen:

android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"

Sie können Formatstrings und Pluralformen durch Angabe von Parametern auswerten:

android:text="@{@string/nameFormat(firstName, lastName)}"
android:text="@{@plurals/banana(bananaCount)}"

Sie können Property-Referenzen und Ansichten Referenzen als Ressourcenparameter:

android:text="@{@string/example_resource(user.lastName, exampleText.text)}"

Wenn ein Plural mehrere Parameter annimmt, übergeben Sie alle Parameter:

  Have an orange
  Have %d oranges

android:text="@{@plurals/orange(orangeCount, orangeCount)}"

Einige Ressourcen erfordern eine explizite Typauswertung, wie im Folgenden gezeigt. Tabelle:

Ereignisverarbeitung

Mit der Datenbindung können Sie Ereignisse zur Verarbeitung von Ausdrücken schreiben, die von die Ansichten, zum Beispiel die onClick() . Ereignisattributnamen richten sich nach dem Namen der Listener-Methode, mit wenigen Ausnahmen. Beispiel: View.OnClickListener hat eine onClick()-Methode, sodass das Attribut für dieses Ereignis android:onClick ist.

Es gibt einige spezielle Ereignis-Handler für das Click-Event, für die ein anderes Attribut als android:onClick, um einen Konflikt zu vermeiden. Sie können die folgenden Attributen, um diese Art von Konflikten zu vermeiden:

Sie können diese beiden Methoden verwenden, die in den Abschnitten verwenden, um ein Ereignis zu verarbeiten:

• Methodenreferenzen: In Ausdrücken können Sie Folgendes tun: Referenzmethoden, die der Signatur der Listener-Methode entsprechen. Wann? wenn ein Ausdruck eine Methodenreferenz ergibt, wird die Methode mit der Datenbindung -Referenz- und Eigentümerobjekt in einem Listener und legt diesen Listener auf dem Zielansicht. Wenn der Ausdruck null ergibt, gilt für die Datenbindung nichts Erstellen Sie einen Listener und legen Sie stattdessen einen null-Listener fest.
• Listener-Bindungen: Dies sind Lambda-Ausdrücke, die ausgewertet, wenn das Ereignis eintritt. Die Datenbindung erstellt immer einen Listener, der für die Ansicht festgelegt wird. Wenn das Ereignis gesendet wird, Listener den Lambda-Ausdruck auswertet.

Methodenreferenzen

Sie können Ereignisse direkt an Handler-Methoden binden, ähnlich wie zuweisen android:onClick in ein Methode in einer Aktivität. Ein Vorteil gegenüber der View onClick-Attribut Ausdruck wird bei der Kompilierung verarbeitet. Wenn die Methode nicht existiert oder Signatur nicht korrekt ist, erhalten Sie einen Fehler beim Kompilieren.

Der Hauptunterschied zwischen Methodenverweisen und Listener-Bindungen besteht darin, dass die Die tatsächliche Listener-Implementierung wird beim Binden der Daten erstellt, nicht beim ausgelöst. Wenn Sie den Ausdruck lieber auswerten möchten, wenn das Ereignis verwenden Sie Listener-Bindungen.

Um dem Handler ein Ereignis zuzuweisen, verwenden Sie einen normalen Bindungsausdruck mit dem value ist der aufzurufende Methodenname. Hier ein Beispiel: Layout-Datenobjekt:

class MyHandlers {
    fun onClickFriend(view: View) { ... }
}

public class MyHandlers {
    public void onClickFriend(View view) { ... }
}

Der Binding-Ausdruck kann den Klick-Listener für eine Ansicht der onClickFriend()-Methode:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
   <data>
       <variable name="handlers" type="com.example.MyHandlers"/>
       <variable name="user" type="com.example.User"/>
   </data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.firstName}"
           android:onClick="@{handlers::onClickFriend}"/>
   </LinearLayout>
</layout>

Listener-Bindungen

Listener-Bindungen sind Bindungsausdrücke, die beim Eintreten eines Ereignisses ausgeführt werden. Sie ähneln Methodenreferenzen, ermöglichen jedoch die Ausführung einer beliebigen Datenbindung. Ausdrücke. Diese Funktion ist mit dem Android-Gradle-Plug-in für Gradle verfügbar Version 2.0 und höher.

Bei Methodenreferenzen müssen die Parameter der Methode mit den Parametern der den Event-Listener. In Listener-Bindungen muss nur der Rückgabewert mit dem Parameter erwarteter Rückgabewert des Listeners, es sei denn, er erwartet void. Für Betrachten Sie beispielsweise die folgende Presenter-Klasse mit einem onSaveClick() :

class Presenter {
    fun onSaveClick(task: Task){}
}

public class Presenter {
    public void onSaveClick(Task task){}
}

So binden Sie das Click-Event an die onSaveClick()-Methode:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable name="task" type="com.android.example.Task" />
        <variable name="presenter" type="com.android.example.Presenter" />
    </data>
    <LinearLayout android:layout_width="match_parent" android:layout_height="match_parent">
        <Button android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:onClick="@{() -> presenter.onSaveClick(task)}" />
    </LinearLayout>
</layout>

Wenn ein Callback in einem Ausdruck verwendet wird, erstellt die Datenbindung automatisch den und registriert ihn für das -Ereignis. Wenn die Ansicht den enthält, wertet die Datenbindung den angegebenen Ausdruck aus. Wie bei der regulären Bindung erhalten Sie die Null- und Thread-Sicherheit der Datenbindung, während diese Listener-Ausdrücke ausgewertet werden.

Im vorherigen Beispiel wurde der Parameter view, der an onClick(View) übergeben wird, nicht definiert ist. Listener-Bindungen bieten zwei Auswahlmöglichkeiten für Listener-Parameter: können Sie alle Parameter für die Methode ignorieren oder sie benennen. Wahlweise Um die Parameter zu benennen, können Sie sie in Ihrem Ausdruck verwenden. Zum Beispiel haben Sie kann den vorherigen Ausdruck so schreiben:

android:onClick="@{(view) -> presenter.onSaveClick(task)}"

Wenn Sie den Parameter in dem Ausdruck verwenden möchten, können Sie dies wie folgt tun:

class Presenter {
    fun onSaveClick(view: View, task: Task){}
}

public class Presenter {
    public void onSaveClick(View view, Task task){}
}

android:onClick="@{(theView) -> presenter.onSaveClick(theView, task)}"

Außerdem können Sie einen Lambda-Ausdruck mit mehr als einem Parameter verwenden:

class Presenter {
    fun onCompletedChanged(task: Task, completed: Boolean){}
}

public class Presenter {
    public void onCompletedChanged(Task task, boolean completed){}
}

<CheckBox android:layout_width="wrap_content" android:layout_height="wrap_content"
      android:onCheckedChanged="@{(cb, isChecked) -> presenter.completeChanged(task, isChecked)}" />

Wenn das Ereignis, das Sie überwachen möchten, einen Wert zurückgibt, dessen Typ nicht void ist, wird Ihr Ausdrücke müssen auch denselben Werttyp zurückgeben. Wenn Sie zum Beispiel auf Berührung und Hold-Ereignis (langer Klick) enthält, muss der Ausdruck ein boolesch.

class Presenter {
    fun onLongClick(view: View, task: Task): Boolean { }
}

public class Presenter {
    public boolean onLongClick(View view, Task task) { }
}

android:onLongClick="@{(theView) -> presenter.onLongClick(theView, task)}"

Wenn der Ausdruck aufgrund von null-Objekten nicht ausgewertet werden kann, wird die Datenbindung zurückgegeben Den Standardwert für diesen Typ, z. B. null für Referenztypen, 0 für int oder false für boolean.

Wenn Sie einen Ausdruck mit einem Prädikat verwenden müssen, z. B. ternär sind, können Sie void als Symbol verwenden:

android:onClick="@{(v) -> v.isVisible() ? doSomething() : void}"

Komplexe Zuhörer vermeiden

Listener-Ausdrücke sind leistungsfähig und können das Lesen Ihres Codes erleichtern. Am Listener mit komplexen Ausdrücken machen Layouts hingegen schwieriger. zu lesen und zu pflegen. Halten Sie Ihre Ausdrücke so einfach wie die Weitergabe verfügbarer Daten von Ihrer Benutzeroberfläche in Ihre Callback-Methode ein. Implementieren Sie jede Geschäftslogik innerhalb des Callback-Methode, die Sie über den Listener-Ausdruck aufrufen.

Importe, Variablen und Einbeziehung

Die Datenbindungsbibliothek bietet Features wie Importe, Variablen und beinhaltet. Mit Importen lassen sich Klassen einfach in Ihren Layoutdateien referenzieren. Mit Variablen können Sie eine Eigenschaft beschreiben, die in Bindungsausdrücken verwendet werden kann. Mit „Includes“ kannst du komplexe Layouts in deiner App wiederverwenden.

Importe

Mit Importen können Sie Klassen innerhalb Ihrer Layoutdatei referenzieren, z. B. in verwaltetem Code. Du kannst null oder mehr import-Elemente innerhalb des data-Elements verwenden. Die Mit dem folgenden Codebeispiel wird die Klasse View in die Layoutdatei importiert:

<data>
    <import type="android.view.View"/>
</data>

Wenn Sie die View-Klasse importieren, können Sie in Ihren Bindungsausdrücken darauf verweisen. Das folgende Beispiel zeigt, wie Sie auf die VISIBLE und GONE-Konstanten der Klasse View:

<TextView
   android:text="@{user.lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:visibility="@{user.isAdult ? View.VISIBLE : View.GONE}"/>

Typaliasse

Wenn es Konflikte mit Klassennamen gibt, können Sie eine der Klassen in einen Alias. Im folgenden Beispiel wird die Klasse View in der Paket mit com.example.real.estate nach Vista:

<import type="android.view.View"/>
<import type="com.example.real.estate.View"
        alias="Vista"/>

Sie können dann mit Vista auf com.example.real.estate.View und View verweisen. , um in der Layoutdatei auf android.view.View zu verweisen.

Andere Kurse importieren

Sie können importierte Typen als Typverweise in Variablen und Ausdrücken verwenden. Die Das folgende Beispiel zeigt, wie User und List als Variablentyp verwendet werden:

<data>
    <import type="com.example.User"/>
    <import type="java.util.List"/>
    <variable name="user" type="User"/>
    <variable name="userList" type="List&lt;User>"/>
</data>

Sie können die importierten Typen verwenden, um Teile eines Ausdrucks umzuwandeln. Die folgenden Im Beispiel wird das Attribut connection in den Typ User umgewandelt:

<TextView
   android:text="@{((User)(user.connection)).lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

Sie können importierte Typen auch verwenden, wenn Sie auf statische Felder und Methoden in Ausdrücke. Mit dem folgenden Code werden die Klasse MyStringUtils und die Verweise importiert capitalize-Methode:

<data>
    <import type="com.example.MyStringUtils"/>
    <variable name="user" type="com.example.User"/>
</data>
…
<TextView
   android:text="@{MyStringUtils.capitalize(user.lastName)}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

Wie der verwaltete Code wird java.lang.* automatisch importiert.

Variablen

Du kannst mehrere variable-Elemente innerhalb des data-Elements verwenden. Jedes Das variable-Element beschreibt eine Eigenschaft, die für das zu verwendende Layout festgelegt werden kann. in Bindungsausdrücken in der Layoutdatei. Im folgenden Beispiel wird deklariert, die Variablen user, image und note:

<data>
    <import type="android.graphics.drawable.Drawable"/>
    <variable name="user" type="com.example.User"/>
    <variable name="image" type="Drawable"/>
    <variable name="note" type="String"/>
</data>

Die Variablentypen werden zum Kompilierungszeitpunkt überprüft. Wenn also eine Variable Observable oder ist ein Beobachtbarkeitserhebung die im Typ widergespiegelt werden muss. Wenn die Variable eine Basisklasse oder Schnittstelle ist in der die Observable-Schnittstelle nicht implementiert ist, sind die Variablen nicht beobachtet.

Wenn es verschiedene Layoutdateien für verschiedene Konfigurationen gibt (z. B. Quer- oder Hochformat), werden die Variablen kombiniert. Es darf keine Variablendefinitionen zwischen diesen Layoutdateien.

Die generierte Bindungsklasse verfügt über einen Setter und Getter für jede der Variablen. Die Variablen übernehmen die Standardwerte für den verwalteten Code, bis der Setter festgelegt wird wird aufgerufen: null für Referenztypen, 0 für int, false für boolean usw.

Eine spezielle Variable namens context wird zur Verwendung in Bindungsausdrücken generiert nach Bedarf. Der Wert für context ist der Context-Objekt aus dem getContext()-Methode. Die Die Variable „context“ wird durch eine explizite Variablendeklaration überschrieben, Namen.

Umfasst

Sie können der Bindung eines enthaltenen Layouts Variablen aus der enthaltenden App-Namespace und den Variablennamen in einem Attribut verwenden. Die Das folgende Beispiel zeigt die eingefügten user-Variablen aus den name.xml- und contact.xml Layoutdateien:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:bind="http://schemas.android.com/apk/res-auto">
   <data>
       <variable name="user" type="com.example.User"/>
   </data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <include layout="@layout/name"
           bind:user="@{user}"/>
       <include layout="@layout/contact"
           bind:user="@{user}"/>
   </LinearLayout>
</layout>

Die Datenbindung unterstützt kein Einschließen als direktes untergeordnetes Element eines Zusammenführungselements. Das folgende Layout wird beispielsweise nicht unterstützt:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:bind="http://schemas.android.com/apk/res-auto">
   <data>
       <variable name="user" type="com.example.User"/>
   </data>
   <merge><!-- Doesn't work -->
       <include layout="@layout/name"
           bind:user="@{user}"/>
       <include layout="@layout/contact"
           bind:user="@{user}"/>
   </merge>
</layout>