Mengikat tampilan tata letak ke Komponen Arsitektur

Library AndroidX menyertakan kursus Architecture Komponen, yang dapat Anda untuk merancang aplikasi yang tangguh, mudah diuji, dan mudah dikelola. Library Data Binding berfungsi lancar dengan Arsitektur Komponen untuk lebih menyederhanakan pengembangan UI Anda. Tata letak di aplikasi Anda dapat mengikat ke data di Komponen Arsitektur, yang membantu Anda mengelola siklus proses pengontrol UI dan memberi tahu UI tentang perubahan data.

Halaman ini menunjukkan cara menggabungkan Komponen Arsitektur ke dalam aplikasi Anda untuk mendapatkan hasil maksimal dari penggunaan Library Data Binding.

Menggunakan LiveData untuk memberitahukan perubahan data ke UI

Anda dapat menggunakan objek LiveData sebagai sumber data binding untuk otomatis memberi tahu UI tentang perubahan layanan otomatis dan data skalabel. Untuk informasi selengkapnya tentang Komponen Arsitektur ini, lihat LiveData ringkasan.

Tidak seperti objek yang mengimplementasikan Observable—seperti dapat diamati kolom—LiveData tahu tentang siklus hidup observer yang berlangganan data perubahan. Pengetahuan ini memberikan banyak manfaat, seperti yang dijelaskan dalam keuntungan menggunakan LiveData. Di Android Studio versi 3.1 dan yang lebih baru, Anda dapat mengganti kolom yang dapat diamati dengan objek LiveData dalam kode data binding.

Untuk menggunakan objek LiveData dengan class binding, Anda perlu menentukan pemilik siklus proses untuk menentukan cakupan objek LiveData. Hal berikut menentukan aktivitas sebagai pemilik siklus proses setelah class binding dibuat instance-nya:

Kotlin

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

Java

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

Anda dapat menggunakan ViewModel seperti yang dijelaskan di bagian berikut, untuk mengikat data ke tata letak. Dalam komponen ViewModel, Anda dapat menggunakan objek LiveData untuk mengubah data atau menggabungkan beberapa data sumber. Contoh berikut menunjukkan cara mengubah data di ViewModel:

Kotlin

class ScheduleViewModel : ViewModel() {
    val userName: LiveData

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

Java

class ScheduleViewModel extends ViewModel {
    LiveData username;

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

Menggunakan ViewModel untuk mengelola data terkait UI

Library Data Binding berfungsi lancar dengan Komponen ViewModel. ViewModel mengekspos data yang diamati dan direspons perubahannya oleh tata letak. Menggunakan Komponen ViewModel dengan Library Data Binding memungkinkan Anda memindahkan logika UI keluar dari tata letak dan ke dalam komponen, yang lebih mudah diuji. Data Library Binding memastikan tampilan terikat dan tidak terikat dari data jika diperlukan. Sebagian besar pekerjaan yang tersisa terdiri dari memastikan bahwa Anda mengekspos data yang benar. Untuk informasi selengkapnya tentang Arsitektur ini Komponen, lihat ViewModel ringkasan.

Untuk menggunakan komponen ViewModel dengan Library Data Binding, Anda harus membuat instance komponen Anda—yang diturunkan dari ViewModel, dapatkan dari class binding, dan menetapkan komponen ViewModel ke di class binding. Contoh berikut menunjukkan cara menggunakan dengan library tersebut:

Kotlin

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

Java

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

Di tata letak, tetapkan properti dan metode komponen ViewModel Anda ke tampilan yang sesuai menggunakan ekspresi binding, seperti ditunjukkan dalam contoh:

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

Menggunakan ViewModel yang Dapat Diobservasi untuk mendapatkan kontrol lebih besar atas adaptor binding

Anda dapat menggunakan ViewModel komponen yang mengimplementasikan Antarmuka Observable untuk memberi tahu orang lain komponen aplikasi tentang perubahan data, mirip dengan bagaimana Anda akan menggunakan LiveData.

Ada situasi di mana Anda mungkin lebih suka menggunakan Komponen ViewModel yang mengimplementasikan Observable antarmuka atas penggunaan objek LiveData, meskipun Anda kehilangan siklus proses kemampuan pengelolaan LiveData. Menggunakan komponen ViewModel yang menerapkan Observable memberi Anda lebih banyak kontrol atas adaptor binding di . Misalnya, pola ini memberi Anda lebih banyak kontrol atas notifikasi saat data berubah; Anda juga dapat menentukan metode kustom untuk menyetel suatu atribut dalam data binding dua arah.

Untuk menerapkan komponen ViewModel yang dapat diamati, Anda harus membuat class yang mewarisi dari class ViewModel dan mengimplementasikan Observable dalam antarmuka berbasis web yang sederhana. Anda bisa menyediakan logika khusus ketika seorang pengamat berlangganan atau berhenti berlangganan notifikasi menggunakan addOnPropertyChangedCallback() dan removeOnPropertyChangedCallback() metode. Anda juga dapat menyediakan logika khusus yang berjalan saat properti berubah tindakan notifyPropertyChanged() . Contoh kode berikut menunjukkan cara menerapkan objek yang dapat diamati ViewModel:

Kotlin

/**
 * 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)
    }
}

Java

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

Referensi lainnya

Untuk mempelajari data binding lebih lanjut, lihat referensi berikut resource tambahan.