Powiąż widoki układu z komponentami architektury

Biblioteka AndroidaX zawiera architekturę Komponenty, które można wykorzystywać do projektowania zaawansowanych aplikacji, które można przetestować i łatwo utrzymywać. Biblioteka wiązań danych bezproblemowo współpracuje z architekturą komponenty, które jeszcze bardziej upraszczają programowania interfejsu użytkownika. Układy w aplikacji tworzyć powiązania z danymi w komponentach architektury, co pomaga zarządza cyklem życia kontrolera UI i powiadamia go o zmianach w danych.

Na tej stronie dowiesz się, jak włączyć komponenty architektury do swojej aplikacji, jak najlepiej wykorzystać możliwości biblioteki wiązań danych.

Używaj LiveData do powiadamiania UI o zmianach w danych

Obiektów LiveData możesz używać jako: źródła powiązania danych, aby automatycznie powiadamiać UI o zmianach w i skalowalnych danych. Więcej informacji o tym komponencie architektury można znaleźć w artykule LiveData .

Odróżnianie obiektów, które implementują Observable – na przykład zauważalne pola – LiveData obiekty znają cykl życia obserwatorów subskrybujących dane zmian. Wiedza ta zapewnia wiele korzyści, które zostały opisane w zalety używania LiveData. W Android Studio w wersji 3.1 lub nowszej możesz zastępować obserwowalne pola z LiveData obiektami w kodzie powiązania danych.

Aby użyć obiektu LiveData z klasą powiązania, musisz określić właściciela cyklu życia, aby zdefiniować zakres obiektu LiveData. Poniżej w tym przykładzie określa działanie jako właściciela cyklu życia po klasie powiązania utworzono instancję:

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

ViewModel zgodnie z instrukcjami w następnej sekcji, by powiązać dane z układem. W komponencie ViewModel możesz użyć obiektu LiveData do przekształcenia danych lub scalenia wielu danych źródeł. Ten przykład pokazuje, jak przekształcić dane w elemencie ViewModel:

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

Używanie modelu ViewModel do zarządzania danymi związanymi z interfejsem użytkownika

Biblioteka wiązań danych współpracuje bezproblemowo z ViewModel. ViewModel ujawnia dane obserwowane przez układ i reaguje na jego zmiany. Zastosowanie Komponenty ViewModel z biblioteką Data Binding umożliwiają przenoszenie logiki interfejsu użytkownika w układach i komponentach, które łatwiej przetestować. Dane Biblioteka powiązań zapewnia, że widoki danych są powiązane i niepowiązane z danymi w razie potrzeby. Pozostała część pracy polega głównie na upewnieniu się, pokazujesz właściwe dane. Aby uzyskać więcej informacji o tej architekturze Komponent, zapoznaj się z kolumną ViewModel .

Aby używać komponentu ViewModel z biblioteką powiązań danych, musisz utworzyć instancję komponentu, który dziedziczy z instancji ViewModel, zdobądź instancji klasy powiązania i przypisz komponent ViewModel do w klasie powiązania. Poniższy przykład pokazuje, jak używać atrybutu z biblioteką:

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

W układzie przypisz właściwości i metody komponentu ViewModel do odpowiednich widoków za pomocą wyrażeń wiążących, jak pokazano poniżej przykład:

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

Użyj Observable ViewModel, aby uzyskać większą kontrolę nad adapterami powiązań

ViewModel który implementuje kod interfejs Observable aby powiadomić innych o zmianach w danych, podobnie jak w przypadku LiveData obiekt.

Istnieją sytuacje, w których możesz chcieć użyć atrybutu Komponent ViewModel, który implementuje Observable za pomocą obiektów LiveData, nawet jeśli utracisz cykl życia możliwości zarządzania LiveData. Za pomocą komponentu ViewModel, który Observable daje większą kontrolę nad adapterami . Ten wzór zapewnia na przykład większą kontrolę nad powiadomieniami gdy dane ulegną zmianie; pozwala też określić niestandardową metodę ustawiania wartości atrybutu w dwukierunkowym wiązaniu danych.

Aby zaimplementować obserwowalny komponent ViewModel, musisz utworzyć klasę, która dziedziczy z klasy ViewModel i implementuje funkcję Observable za pomocą prostego interfejsu online. Możesz zastosować niestandardową logikę, gdy obserwator subskrybują lub anuluje subskrypcję powiadomień przez addOnPropertyChangedCallback() oraz removeOnPropertyChangedCallback() . Możesz też udostępnić niestandardową logikę uruchamianą, gdy właściwości zmienią się notifyPropertyChanged() . Poniższy przykładowy kod pokazuje, jak wdrożyć obiekt dostrzegalny 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);
    }
}