Layoutansichten an Architekturkomponenten binden

Die AndroidX-Bibliothek enthält die Architektur Komponenten, die Sie bei der Entwicklung robuster, testbarer und wartbarer Apps. Die Datenbindungsbibliothek arbeitet nahtlos mit der Architektur zusammen Komponenten zur weiteren Vereinfachung der Entwicklung Ihrer UI. Die Layouts in Ihrer App kann eine Bindung an die Daten in den Architekturkomponenten möglich sein, was Ihnen den Lebenszyklus des UI-Controllers verwalten und die UI über Änderungen in den Daten informieren.

Auf dieser Seite erfahren Sie, wie Sie die Architekturkomponenten in Ihre Anwendung einbinden, um die Datenbindungsbibliothek optimal nutzen.

LiveData verwenden, um die Benutzeroberfläche über Datenänderungen zu informieren

Sie können LiveData-Objekte verwenden als Datenbindungsquelle automatisch die UI über Änderungen in der Daten. Weitere Informationen zu dieser Architekturkomponente finden Sie im Abschnitt zu LiveData Übersicht.

Im Gegensatz zu Objekten, die Observable – z. B. beobachtbar Felder: LiveData Objekte wissen über den Lebenszyklus der Beobachter, die die Daten abonniert haben. Änderungen. Dieses Wissen bietet viele Vorteile, die im Artikel Die Vorteile der Verwendung von LiveData Ab Android Studio Version 3.1 können Sie beobachtbare Felder ersetzen mit LiveData-Objekten in Ihrem Datenbindungscode.

Wenn Sie ein LiveData-Objekt mit Ihrer Bindungsklasse verwenden möchten, müssen Sie ein Lebenszyklusinhaber, um den Bereich des LiveData-Objekts zu definieren. Die folgenden Beispiel gibt die Aktivität als Lebenszyklusinhaber nach der Bindungsklasse an instanziiert wurde:

class ViewModelActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // Inflate view and obtain an instance of the binding class.
        val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)

        // Specify the current activity as the lifecycle owner.
        binding.setLifecycleOwner(this)
    }
}

class ViewModelActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Inflate view and obtain an instance of the binding class.
        UserBinding binding = DataBindingUtil.setContentView(this, R.layout.user);

        // Specify the current activity as the lifecycle owner.
        binding.setLifecycleOwner(this);
    }
}

Sie können ein ViewModel- Komponente, wie im folgenden Abschnitt erläutert, um die Daten an das Layout zu binden. In der Komponente ViewModel können Sie das LiveData-Objekt verwenden, um die Daten zu transformieren oder mehrere Daten zusammenzuführen. Quellen. Das folgende Beispiel zeigt, wie die Daten im ViewModel transformiert werden:

class ScheduleViewModel : ViewModel() {
    val userName: LiveData

    init {
        val result = Repository.userName
        userName = Transformations.map(result) { result -> result.value }
    }
}

class ScheduleViewModel extends ViewModel {
    LiveData username;

    public ScheduleViewModel() {
        String result = Repository.userName;
        userName = Transformations.map(result, result -> result.value);
    }
}

ViewModel zum Verwalten von UI-bezogenen Daten verwenden

Die Datenbindungsbibliothek arbeitet nahtlos mit ViewModel-Komponenten Das ViewModel zeigt die vom Layout beobachteten Daten an und reagiert auf seine Änderungen. Mit ViewModel-Komponenten mit der Datenbindungsbibliothek ermöglichen das Verschieben von UI-Logik Layouts in die Komponenten zu übertragen, die sich leichter testen lassen. Die Daten Die Bindungsbibliothek stellt sicher, dass die Ansichten gebunden und von den Daten getrennt sind. Quelle bei Bedarf. Der Großteil der verbleibenden Arbeit besteht darin, stellen Sie die richtigen Daten bereit. Weitere Informationen zu dieser Architektur Komponente, siehe ViewModel Übersicht.

Wenn Sie die Komponente „ViewModel“ mit der Datenbindungsbibliothek verwenden möchten, müssen Sie instanziieren Sie Ihre Komponente – diese übernimmt den ViewModel, erhalten Sie eine der Bindungsklasse und weisen Sie die Komponente ViewModel einer in der Bindungsklasse. Das folgende Beispiel zeigt, wie Sie die Methode -Komponente mit der Bibliothek:

class ViewModelActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // Obtain the ViewModel component.
        val userModel: UserModel by viewModels()

        // Inflate view and obtain an instance of the binding class.
        val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)

        // Assign the component to a property in the binding class.
        binding.viewmodel = userModel
    }
}

class ViewModelActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Obtain the ViewModel component.
        UserModel userModel = new ViewModelProvider(this).get(UserModel.class);

        // Inflate view and obtain an instance of the binding class.
        UserBinding binding = DataBindingUtil.setContentView(this, R.layout.user);

        // Assign the component to a property in the binding class.
        binding.viewmodel = userModel;
    }
}

Weisen Sie in Ihrem Layout die Eigenschaften und Methoden der ViewModel-Komponente zu mithilfe von Bindungsausdrücken in die entsprechenden Ansichten verschieben, wie im Folgenden gezeigt: Beispiel:

<CheckBox
    android:id="@+id/rememberMeCheckBox"
    android:checked="@{viewmodel.rememberMe}"
    android:onCheckedChanged="@{() -> viewmodel.rememberMeChanged()}" />

Observable ViewModel für mehr Kontrolle über Bindungsadapter verwenden

Sie können ein ViewModel- Komponente, die das Ereignis Observable-Benutzeroberfläche um andere zu benachrichtigen, App-Komponenten über Änderungen der Daten, ähnlich wie bei der Verwendung eines LiveData-Objekt

Es gibt Situationen, in denen Sie Komponente „ViewModel“, die die Komponente „Observable“ implementiert LiveData-Objekten, auch wenn Sie den Lebenszyklus verlieren Verwaltungsfunktionen von LiveData. Mit einer ViewModel-Komponente, die implementiert Observable, gibt Ihnen mehr Kontrolle über die Bindungsadapter in Ihrem Mit diesem Muster hast du beispielsweise mehr Kontrolle über die Benachrichtigungen wenn sich Daten ändern; Sie können auch eine benutzerdefinierte Methode angeben, -Wert eines Attributs in der bidirektionalen Datenbindung.

Um eine beobachtbare ViewModel-Komponente zu implementieren, musst du eine Klasse erstellen, die übernimmt die Klasse ViewModel und implementiert die Observable . Sie können benutzerdefinierte Logik bereitstellen, wenn ein Beobachter Benachrichtigungen über die addOnPropertyChangedCallback() und removeOnPropertyChangedCallback() . Sie können auch eine benutzerdefinierte Logik bereitstellen, die ausgeführt wird, wenn sich Eigenschaften in die notifyPropertyChanged() . Das folgende Codebeispiel zeigt, wie Sie ein beobachtbares ViewModel:

/**
 * A ViewModel that is also an Observable,
 * to be used with the Data Binding Library.
 */
open class ObservableViewModel : ViewModel(), Observable {
    private val callbacks: PropertyChangeRegistry = PropertyChangeRegistry()

    override fun addOnPropertyChangedCallback(
            callback: Observable.OnPropertyChangedCallback) {
        callbacks.add(callback)
    }

    override fun removeOnPropertyChangedCallback(
            callback: Observable.OnPropertyChangedCallback) {
        callbacks.remove(callback)
    }

    /**
     * Notifies observers that all properties of this instance have changed.
     */
    fun notifyChange() {
        callbacks.notifyCallbacks(this, 0, null)
    }

    /**
     * Notifies observers that a specific property has changed. The getter for the
     * property that changes must be marked with the @Bindable annotation to
     * generate a field in the BR class to be used as the fieldId parameter.
     *
     * @param fieldId The generated BR id for the Bindable field.
     */
    fun notifyPropertyChanged(fieldId: Int) {
        callbacks.notifyCallbacks(this, fieldId, null)
    }
}

/**
 * A ViewModel that is also an Observable,
 * to be used with the Data Binding Library.
 */
class ObservableViewModel extends ViewModel implements Observable {
    private PropertyChangeRegistry callbacks = new PropertyChangeRegistry();

    @Override
    protected void addOnPropertyChangedCallback(
            Observable.OnPropertyChangedCallback callback) {
        callbacks.add(callback);
    }

    @Override
    protected void removeOnPropertyChangedCallback(
            Observable.OnPropertyChangedCallback callback) {
        callbacks.remove(callback);
    }

    /**
     * Notifies observers that all properties of this instance have changed.
     */
    void notifyChange() {
        callbacks.notifyCallbacks(this, 0, null);
    }

    /**
     * Notifies observers that a specific property has changed. The getter for the
     * property that changes must be marked with the @Bindable annotation to
     * generate a field in the BR class to be used as the fieldId parameter.
     *
     * @param fieldId The generated BR id for the Bindable field.
     */
    void notifyPropertyChanged(int fieldId) {
        callbacks.notifyCallbacks(this, fieldId, null);
    }
}