introduction

J'utilise Data Binding dans un projet de développement et j'écrirai un article sur ce que j'ai appris.

Cette fois, j'ai appris à utiliser DataBinding pour surveiller les modifications des propriétés des objets de classe de données et les refléter dans l'affichage View.

Application d'apprentissage créée cette fois

L'affichage du texte de ① et ② est commuté dynamiquement d'avant en arrière chaque fois que vous appuyez sur le bouton "Changer". "Doraemon" ⇄ "Extended"

①

②

Dossier d'implémentation

build.gradle(:app)
activity_main.xml -- Character.java (classe de modèle) --`` EventHandlers.java '' (interface)
MainActivity.java

Je vais implémenter

1. Introduction de DataBinding

Ajout de dataBinding {enabled = true} '' à build.gradle (: app) ''

`build.gradle`


apply plugin: 'com.android.application'

android {
    compileSdkVersion 30
    buildToolsVersion "30.0.2"

    defaultConfig {
        applicationId "com.android.databindingjava"
        minSdkVersion 24
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

    //Ajouter une description
    dataBinding {
        enabled = true
    }
}

dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar"])
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'

}

2. Définissez une classe de modèle pour surveiller les modifications

`Character.java`


//Hériter de BaseObservable
public class Character extends BaseObservable {
    private String name;

    public Character(String name) {
        this.name = name;
    }

    //à getName@BR constant pour la surveillance en donnant Bindable.le nom est généré
    @Bindable
    public String getName() {
        return name;
    }

    //notifyPropertyChanged dans setName(BR.name)En accordant
    //BR du côté de la mise en page.getName correspondant au nom()Est appelé (getName est appelé du côté de la mise en page lorsque setName est terminé)
    public void setName(String name) {
        this.name = name;

        notifyPropertyChanged(BR.name);
    }
}

Pour refléter les changements dans la vue

--Héritage de BaseObservable '' --Ajoutez @ Bindable '' à getName '' pour générer BR.name '', qui est une constante de surveillance.

Ecrire notifyPropertyChanged (BR.name); dans setName

En faisant cela, getName '' sera appelé du côté de la mise en page lorsque setNameest exécuté, et lorsque la valeur de name`` est modifiée, le changement sera reflété dans la vue.

3. Définissez une interface pour modifier les données

`EventHandlers.java`


public interface EventHandlers {
    //Je veux correspondre à l'événement de clic, donc l'argument est View.Faites-en la même chose que onClick de OnClickListener (vue Vue)
    void onChangeClick(View view);
}

Définir le gestionnaire d'événements à définir dans la présentation en tant qu'interface

4. Créez un fichier de mise en page pour refléter les modifications

`activity_main.xml`


<?xml version="1.0" encoding="utf-8"?>

<!--En définissant l'itinéraire vers la mise en page, elle sera reconnue comme une mise en page correspondant à la liaison de données.-->
<!-- activity_main.xml =>ActivityMainBinding De cette manière, une classe Binding est automatiquement créée en fonction du nom de fichier xml.-->
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <!--Objet de liaison-->
    <data>
        <!--Personnage nommé par cette description(Tout)Est associé à l'objet de classe User-->
        <variable name="character" type="com.android.databindingjava.Character" />
        <!--EventHandlers nommé par cette description(Tout)Le gestionnaire (interface) est défini dans-->
        <variable name="eventHandlers" type="com.android.databindingjava.EventHandlers" />
    </data>

    <!-- Views-->
    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <TextView
            android:id="@+id/text_view_user_name"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textSize="30dp"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            android:text="@{character.name}" />

        <Button
            android:id="@+id/button_change"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textSize="30dp"
            android:text="changement"
            android:onClick="@{eventHandlers.onChangeClick}"
            app:layout_constraintBottom_toTopOf="@id/text_view_user_name"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent" />

    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

Accès à la classe de modèle à partir de la mise en page

<variable name = "character" type = "com.android.databindingjava.Character" /> définit un objet de classe Character avec le caractère de nom dans le fichier de mise en page et utilise l'objet dans le fichier de mise en page. devenir capable de.

@ {character.name} Avec cette description, vous pouvez accéder à la propriété name de la classe Character, et android: text = "@ {character.name}" définit la valeur de la propriété sur text.

Le contenu de `` @ {} '' est conçu pour autoriser null, et même s'il est nul, NullPointerException ne se produira pas.

Définir le gestionnaire d'événements pour l'élément de disposition

<variable name = "eventHandlers" type = "com.android.databindingjava.EventHandlers" /> définit l'interface EventHandlers dans le fichier de mise en page avec le nom eventHandlers, et vous pouvez accéder à l'interface dans le fichier de mise en page. Sera.

@ {eventHandlers.onChangeClick} Avec cette description, vous pouvez accéder à onChangeClick de l'interface EventHandlers, et lorsque vous cliquez en écrivant android: onClick = "@ {eventHandlers.onChangeClick}" dans l'élément Button OnChangeClick sera appelé. (* Une description dans MainActivity.java, qui sera décrite plus tard, est également requise)

5. Définir le processus DataBinding dans MainActivity

`MainActivity.java`


//Implémenter EventHandlers (interface)
public class MainActivity extends AppCompatActivity implements EventHandlers {

    private Character chara = new Character("Doraemon");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // activity_main.Créer une instance de liaison de la classe correspondant à xml
        ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
        // activity_main.Définir chara en caractère dans xml
        binding.setCharacter(chara);
        // activity_main.Définissez MainActivity sur eventHandlers dans xml
        binding.setEventHandlers(this);
    }

    // button_Cliquez sur le traitement des événements du changement (interface)
    @Override
    public void onChangeClick(View view) {

        //Changer la chaîne de caractères à définir en fonction de la chaîne de caractères du nom de chara
        if (chara.getName().equals("Doraemon")) {
            chara.setName("Étiré");
        } else {
            chara.setName("Doraemon");
        }
    }
}

En créant un fichier de mise en page avec la racine définie sur `` '', une classe Binding correspondant au nom de fichier xml est automatiquement créée. Dans ce cas, activity_main.xml => ActivityMainBinding (.java)

Le traitement suivant est effectué dans `` onCreate ''

--Créez une instance avec ActivityMainBinding binding = DataBindingUtil.setContentView (this, R.layout.activity_main); --Définissez chara en caractère dans le fichier de mise en page avec binding.setCharacter (chara); '' --Définissez MainActivity sur eventHandlers dans le fichier de mise en page avec binding.setEventHandlers (this); ``

Ensuite, l'interface onChangeClick est implémentée et le processus de modification des données selon la valeur de chaîne de caractères TextView sans méthode est écrit.

Site de référence

Cet article du mien est un désordre de référence à cet article. C'était vraiment facile à comprendre! Merci beaucoup!

Liaison de données Android ~ Super Introduction ~

finalement

Cette fois, c'est une application simple, mais le projet réel est volumineux et il est difficile de lire le code. Je continuerai à apprendre davantage.

Nous vous serions reconnaissants de bien vouloir commenter toute erreur ou suggestion.

[Android / Java] En savoir plus sur DataBinding