Cómo vincular vistas de diseño con componentes de arquitectura

La biblioteca de AndroidX incluye la Arquitectura Componentes, que puedes para diseñar apps sólidas, que puedan someterse a pruebas y admitan mantenimiento. La biblioteca de vinculación de datos funciona a la perfección con la arquitectura Componentes para simplificar aún más la el desarrollo de la IU. Los diseños de tu app puedes vincularte a los datos en los componentes de la arquitectura, que te ayudan administrar el ciclo de vida del controlador de IU y notificar a la IU sobre cambios en los datos

En esta página, se muestra cómo incorporar los componentes de la arquitectura en tu app para lo siguiente: aprovechar al máximo la biblioteca de vinculación de datos.

Usa LiveData para notificar a la IU los cambios en los datos

Puedes usar objetos LiveData como la fuente de vinculación de datos para notificar automáticamente a la IU sobre los cambios en la de datos no estructurados. Para obtener más información sobre este componente de la arquitectura, consulta la documentación de LiveData descripción general.

A diferencia de los objetos que implementan Observable, como observables campos: LiveData conocen el ciclo de vida de los observadores suscritos a los datos cambios. Este conocimiento brinda muchos beneficios, que se explican en el artículo El de usar LiveData. En Android Studio 3.1 y versiones posteriores, puedes reemplazar campos observables con objetos LiveData en el código de vinculación de datos.

Para usar un objeto LiveData con tu clase de vinculación, debes especificar un propietario del ciclo de vida para definir el alcance del objeto LiveData. Lo siguiente ejemplo especifica la actividad como el propietario del ciclo de vida después de la clase de vinculación instancia:

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

Puedes usar un ViewModel como se explica en la siguiente sección, para vincular los datos al diseño. En el componente ViewModel, puedes usar el objeto LiveData para transformar los datos o combinar varios datos fuentes de datos. En el siguiente ejemplo, se muestra cómo transformar los datos en 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);
    }
}

Usa ViewModel para administrar datos relacionados con la IU

La biblioteca de vinculación de datos funciona a la perfección con Componentes ViewModel El ViewModel Expone los datos que el diseño observa y reacciona a sus cambios. Usando Los componentes ViewModel con la biblioteca de vinculación de datos te permiten mover la lógica de la IU. de los diseños y los componentes, que son más fáciles de probar. Los datos La biblioteca de vinculación garantiza que las vistas estén vinculadas y desvinculadas de los datos. fuente cuando sea necesario. La mayor parte del trabajo restante consiste en asegurarse de que estás exponiendo los datos correctos. Obtén más información sobre esta arquitectura Componente, consulta la clase ViewModel descripción general.

Para usar el componente ViewModel con la biblioteca de vinculación de datos, debes crear una instancia de tu componente, que hereda del ViewModel, obtén un de tu clase de vinculación y asigna tu componente ViewModel a una en la clase de vinculación. En el siguiente ejemplo, se muestra cómo usar la con la biblioteca:

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

En el diseño, asigna las propiedades y los métodos del componente ViewModel. a las vistas correspondientes usando expresiones de vinculación, como se muestra a continuación ejemplo:

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

Utiliza un ViewModel observable para tener más control sobre los adaptadores de vinculación

Puedes usar un ViewModel que implementa las Interfaz de Observable para notificar a otros los componentes de la app sobre los cambios en los datos, similar a lo que harías con un objeto LiveData.

Hay situaciones en las que podrías preferir usar un Componente ViewModel que implementa Observable en lugar de usar objetos LiveData, incluso si pierdes el ciclo de vida de administración de LiveData. Con un componente ViewModel que implementa Observable, lo que te da más control sobre los adaptadores de vinculación en tu . Por ejemplo, este patrón te da más control sobre las notificaciones cuando los datos cambian; sino que también te permite especificar un método personalizado de un atributo en la vinculación de datos bidireccional.

Para implementar un componente ViewModel observable, debes crear una clase que se hereda de la clase ViewModel e implementa Observable interfaz de usuario. Puedes proporcionar lógica personalizada cuando un observador se suscribe anula la suscripción a las notificaciones con el addOnPropertyChangedCallback() y removeOnPropertyChangedCallback() . También puedes proporcionar una lógica personalizada que se ejecute cuando las propiedades cambien en el notifyPropertyChanged() . En el siguiente ejemplo de código, se muestra cómo implementar un 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);
    }
}