İfade dili, görünümler tarafından gönderilen etkinlikleri işleyen ifadeler yazmanıza olanak tanır. Veri Bağlama Kitaplığı, düzendeki görünümleri veri nesnelerinize bağlamak için gereken sınıfları otomatik olarak oluşturur.
Veri bağlama düzeni dosyaları biraz farklıdır. Bunlar layout
kök etiketiyle başlar, ardından data
öğesi ve view
kök öğesi gelir. Bu görünüm öğesi, bağlayıcı olmayan bir düzen dosyasındaki kök dizininizin bulunduğu öğedir. Aşağıdaki kod, örnek bir düzen dosyası gösterir:
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
<data>
<variable name="user" type="com.example.User"/>
</data>
<LinearLayout
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.firstName}"/>
<TextView android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.lastName}"/>
</LinearLayout>
</layout>
data
içindeki user
değişkeni, bu düzende kullanılabilecek bir özelliği tanımlar:
<variable name="user" type="com.example.User" />
Düzen içindeki ifadeler, özellik özelliklerine @{}
söz dizimi kullanılarak yazılır. Aşağıdaki örnekte TextView
metni, user
değişkeninin firstName
özelliğine ayarlanmıştır:
<TextView android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.firstName}" />
Veri nesneleri
User
varlığını tanımlayacak düz bir nesneniz olduğunu varsayalım:
Kotlin
data class User(val firstName: String, val lastName: String)
Java
public class User { public final String firstName; public final String lastName; public User(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } }
Bu tür nesneler, asla değişmeyen verilere sahiptir. Uygulamalarda verilerin bir kez okunup sonradan hiç değişmemesi yaygın bir durumdur. Aşağıdaki örnekte gösterildiği gibi, bir dizi kuralı izleyen bir nesne kullanmak da mümkündür (ör. Java programlama dilinde erişimci yöntemlerini kullanma gibi):
Kotlin
// Not applicable in Kotlin. data class User(val firstName: String, val lastName: String)
Java
public class User { private final String firstName; private final String lastName; public User(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } public String getFirstName() { return this.firstName; } public String getLastName() { return this.lastName; } }
Veri bağlama açısından bakıldığında bu iki sınıf eşdeğerdir. android:text
özelliği için kullanılan @{user.firstName}
ifadesi, ilk sınıftaki firstName
alanına ve ikinci sınıftaki getFirstName()
yöntemine erişir. Ayrıca, bu yöntem varsa firstName()
olarak da çözümlenir.
Verileri bağlama
Her düzen dosyası için bir bağlama sınıfı oluşturulur. Varsayılan olarak sınıfın adı, düzen dosyasının adına dayanır ve düzen dosyasının adına Binding son eki eklenmiş olarak Pascal büyük/küçük harf biçimine dönüştürülür. Örneğin, önceki düzen dosya adı activity_main.xml
olduğundan karşılık gelen oluşturulan bağlama sınıfı ActivityMainBinding
olur.
Bu sınıf, düzen özelliklerindeki user
değişkeni gibi düzenin görünümlerine ilişkin tüm bağlamaları içerir ve bağlama ifadeleri için nasıl değer atanacağını bilir. Bağlamaları, aşağıdaki örnekte gösterildiği gibi büyütürken oluşturmanızı öneririz:
Kotlin
override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) val binding: ActivityMainBinding = DataBindingUtil.setContentView( this, R.layout.activity_main) binding.user = User("Test", "User") }
Java
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main); User user = new User("Test", "User"); binding.setUser(user); }
Çalışma zamanında uygulama, kullanıcı arayüzünde Test kullanıcısını görüntüler. Alternatif olarak, görünümü aşağıdaki örnekte gösterildiği gibi bir LayoutInflater
kullanarak da alabilirsiniz:
Kotlin
val binding: ActivityMainBinding = ActivityMainBinding.inflate(getLayoutInflater())
Java
ActivityMainBinding binding = ActivityMainBinding.inflate(getLayoutInflater());
Fragment
, ListView
veya RecyclerView
adaptöründe veri bağlama öğeleri kullanıyorsanız aşağıdaki kod örneğinde gösterildiği gibi bağlama sınıflarının veya DataBindingUtil
sınıfının inflate()
yöntemlerini kullanmayı tercih edebilirsiniz:
Kotlin
val listItemBinding = ListItemBinding.inflate(layoutInflater, viewGroup, false) // or val listItemBinding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false)
Java
ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false); // or ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);
İfade dili
Ortak özellikler
İfade dili, yönetilen kodda bulunan ifadelere çok benzer. İfade dilinde aşağıdaki operatörleri ve anahtar kelimeleri kullanabilirsiniz:
- Matematiksel:
+ - / * %
- Dize birleştirme:
+
- Mantıksal:
&& ||
- İkili:
& | ^
- Birli:
+ - ! ~
- Üst karakter:
>> >>> <<
- Karşılaştırma:
== > < >= <=
(<
öğesinin<
olarak kod dışı bırakılması gerekir) instanceof
- Gruplandırma:
()
- Karakter, Dize, sayısal değerler,
null
gibi hazır değerler - Yayınlama
- Yöntem çağrıları
- Alan erişimi
- Dizi erişimi:
[]
- Üçlü operatör:
?:
Bazı örnekler:
android:text="@{String.valueOf(index + 1)}"
android:visibility="@{age > 13 ? View.GONE : View.VISIBLE}"
android:transitionName='@{"image_" + id}'
Eksik işlemler
Yönetilen kodda kullanabileceğiniz ifade söz diziminde aşağıdaki işlemler eksiktir:
this
super
new
- Uygunsuz genel çağrı
Boş birleştirme operatörü
Boş birleştirme operatörü (??
), null
değilse sol işleneni veya null
değilse sağı seçer:
android:text="@{user.displayName ?? user.lastName}"
Bu, işlevsel olarak aşağıdakine eşdeğerdir:
android:text="@{user.displayName != null ? user.displayName : user.lastName}"
Mülk referansları
Bir ifade aşağıdaki biçimi kullanarak sınıftaki bir özelliğe başvuruda bulunabilir. Bu biçim; alanlar, alıcılar ve ObservableField
nesneleri için aynıdır:
android:text="@{user.lastName}"
Boş işaretçi istisnalarından kaçının
Oluşturulan veri bağlama kodu, null
değerlerini otomatik olarak kontrol eder ve boş işaretçi istisnalarını önler. Örneğin, @{user.name}
ifadesinde user
null ise user.name
için varsayılan null
değeri atanır. Yaşın int
türünde olduğu user.age
için referans verirseniz veri bağlama, varsayılan 0
değerini kullanır.
Referansları göster
Bir ifade, aşağıdaki söz dizimini kullanarak düzendeki diğer görünümlere kimlik göre başvuruda bulunabilir:
android:text="@{exampleText.text}"
Aşağıdaki örnekte, TextView
görünümü aynı düzende bir EditText
görünümüne referansta bulunur:
<EditText
android:id="@+id/example_text"
android:layout_height="wrap_content"
android:layout_width="match_parent"/>
<TextView
android:id="@+id/example_output"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{exampleText.text}"/>
Koleksiyonlar
Kolaylık olması için []
operatörünü kullanarak diziler, listeler, seyrek listeler ve haritalar gibi sık kullanılan koleksiyonlara erişebilirsiniz.
<data>
<import type="android.util.SparseArray"/>
<import type="java.util.Map"/>
<import type="java.util.List"/>
<variable name="list" type="List<String>"/>
<variable name="sparse" type="SparseArray<String>"/>
<variable name="map" type="Map<String, String>"/>
<variable name="index" type="int"/>
<variable name="key" type="String"/>
</data>
...
android:text="@{list[index]}"
...
android:text="@{sparse[index]}"
...
android:text="@{map[key]}"
object.key
gösterimini kullanarak haritadaki bir değere de başvuruda bulunabilirsiniz. Örneğin, önceki örnekte @{map[key]}
yerine @{map.key}
kullanabilirsiniz.
Dize değişmez değerleri
Özellik değerini çift tırnak içine almak için tek tırnak kullanabilirsiniz. Böylece, aşağıdaki örnekte gösterildiği gibi, ifadede çift tırnak kullanabilirsiniz:
android:text='@{map["firstName"]}'
Ayrıca, özellik değerini çift tırnak içine alabilirsiniz. Bu işlem sırasında dize değişmez değerleri, burada gösterildiği gibi vurgu işaretleri `
içine alınmalıdır:
android:text="@{map[`firstName`]}"
Kaynaklar
Bir ifade, aşağıdaki söz dizimiyle uygulama kaynaklarına başvurabilir:
android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"
Biçim dizelerini ve çoğulları parametreler sağlayarak değerlendirebilirsiniz:
android:text="@{@string/nameFormat(firstName, lastName)}"
android:text="@{@plurals/banana(bananaCount)}"
Mülk referanslarını iletebilir ve referansları kaynak parametreleri olarak görüntüleyebilirsiniz:
android:text="@{@string/example_resource(user.lastName, exampleText.text)}"
Çoğul birden çok parametre aldığında tüm parametreleri iletin:
Have an orange
Have %d oranges
android:text="@{@plurals/orange(orangeCount, orangeCount)}"
Bazı kaynaklar, aşağıdaki tabloda gösterildiği gibi açık tür değerlendirmesi gerektirir:
Tür | Normal referans | İfade referansı |
---|---|---|
String[] |
@array |
@stringArray |
int[] |
@array |
@intArray |
TypedArray |
@array |
@typedArray |
Animator |
@animator |
@animator |
StateListAnimator |
@animator |
@stateListAnimator |
color int |
@color |
@color |
ColorStateList |
@color |
@colorStateList |
Olay işleme
Veri bağlama, görünümlerden gönderilen ifade işleme etkinliklerini (ör. onClick()
yöntemi) yazmanıza olanak tanır. Etkinlik özelliği adları, birkaç istisna dışında işleyici yönteminin adına göre belirlenir. Örneğin, View.OnClickListener
bir onClick()
yöntemine sahiptir. Dolayısıyla bu etkinliğin özelliği android:onClick
olur.
Çakışmayı önlemek için tıklama etkinliğiyle ilgili olarak android:onClick
dışında bir özelliğe ihtiyaç duyan bazı özel etkinlik işleyiciler vardır. Bu tür çakışmaları önlemek için aşağıdaki özellikleri kullanabilirsiniz:
Sınıf | Dinleyici ayarlayıcı | Özellik |
---|---|---|
SearchView |
setOnSearchClickListener(View.OnClickListener) |
android:onSearchClick |
ZoomControls |
setOnZoomInClickListener(View.OnClickListener) |
android:onZoomIn |
ZoomControls |
setOnZoomOutClickListener(View.OnClickListener) |
android:onZoomOut |
Bir etkinliği işlemek için aşağıdaki bölümlerde ayrıntılı olarak açıklanan bu iki mekanizmayı kullanabilirsiniz:
- Yöntem referansları: İfadelerinizde, işleyici yönteminin imzasına uyan yöntemlere başvurabilirsiniz. Bir ifade, bir yöntem referansı olarak değerlendirildiğinde veri bağlama, yöntem referansını ve sahip nesnesini bir işleyiciye sarmalar ve bu işleyiciyi hedef görünümde ayarlar. İfade
null
olarak değerlendirilirse veri bağlama bir işleyici oluşturmaz ve bunun yerine birnull
işleyicisi ayarlar. - İşleyici bağlamaları: Bunlar, etkinlik gerçekleştiğinde değerlendirilen lambda ifadeleridir. Veri bağlama her zaman görünümde ayarlayan bir işleyici oluşturur. Etkinlik gönderildiğinde, işleyici lambda ifadesini değerlendirir.
Yöntem başvuruları
android:onClick
'i etkinlikteki bir yönteme atayabileceğiniz gibi, etkinlikleri işleyici yöntemlerine doğrudan bağlayabilirsiniz. View
onClick
özelliğiyle karşılaştırıldığında bir avantajı, ifadenin derleme sırasında işlenmesidir. Bu nedenle, yöntem yoksa veya yöntemin imzası yanlışsa derleme zamanı hatası alırsınız.
Yöntem referansları ile dinleyici bağlamaları arasındaki en önemli fark, gerçek dinleyici uygulamasının etkinlik tetiklendiğinde değil, veriler bağlandığında oluşturulmasıdır. Etkinlik meydana geldiğinde ifadeyi değerlendirmeyi tercih ederseniz işleyici bağlamalarını kullanın.
Bir etkinliği işleyiciye atamak için normal bir bağlama ifadesi kullanın. Değer, çağrılacak yöntemin adıdır. Örneğin, aşağıdaki örnek düzen veri nesnesini düşünün:
Kotlin
class MyHandlers { fun onClickFriend(view: View) { ... } }
Java
public class MyHandlers { public void onClickFriend(View view) { ... } }
Bağlama ifadesi, bir görüntüleme için tıklama işleyiciyi aşağıdaki gibi onClickFriend()
yöntemine atayabilir:
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
<data>
<variable name="handlers" type="com.example.MyHandlers"/>
<variable name="user" type="com.example.User"/>
</data>
<LinearLayout
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.firstName}"
android:onClick="@{handlers::onClickFriend}"/>
</LinearLayout>
</layout>
İşleyici bağlamaları
İşleyici bağlamaları, bir etkinlik gerçekleştiğinde çalışan bağlayıcı ifadelerdir. Bunlar, yöntem başvurularına benzer ancak rastgele veri bağlama ifadelerini çalıştırmanıza olanak tanır. Bu özellik, Gradle sürüm 2.0 ve üzeri için Android Gradle Eklentisi ile kullanılabilir.
Yöntem referanslarında, yöntemin parametreleri etkinlik işleyicinin parametreleriyle eşleşmelidir. İşleyici bağlamalarında, void
beklenmiyorsa yalnızca döndürülen değer işleyicinin beklenen döndürme değeriyle eşleşmelidir. Örneğin, onSaveClick()
yöntemine sahip aşağıdaki sunucu sınıfını ele alalım:
Kotlin
class Presenter { fun onSaveClick(task: Task){} }
Java
public class Presenter { public void onSaveClick(Task task){} }
Tıklama etkinliğini onSaveClick()
yöntemine aşağıdaki şekilde bağlayabilirsiniz:
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
<data>
<variable name="task" type="com.android.example.Task" />
<variable name="presenter" type="com.android.example.Presenter" />
</data>
<LinearLayout android:layout_width="match_parent" android:layout_height="match_parent">
<Button android:layout_width="wrap_content" android:layout_height="wrap_content"
android:onClick="@{() -> presenter.onSaveClick(task)}" />
</LinearLayout>
</layout>
Bir ifadede geri çağırma kullanıldığında, veri bağlama gerekli işleyiciyi otomatik olarak oluşturur ve etkinliğe kaydeder. Görünüm etkinliği tetiklediğinde, veri bağlama belirtilen ifadeyi değerlendirir. Normal bağlama ifadelerinde olduğu gibi, bu işleyici ifadeleri değerlendirilirken veri bağlamanın boş ve iş parçacığı güvenliğini elde edersiniz.
Yukarıdaki örnekte, onClick(View)
öğesine geçirilen view
parametresi tanımlanmamıştır. İşleyici bağlamaları, işleyici parametreleri için iki seçenek sağlar: Yöntemdeki tüm parametreleri yoksayabilir veya tümünü adlandırabilirsiniz. Parametreleri adlandırmayı tercih ederseniz bunları ifadenizde kullanabilirsiniz. Örneğin, önceki ifadeyi aşağıdaki gibi yazabilirsiniz:
android:onClick="@{(view) -> presenter.onSaveClick(task)}"
Parametreyi ifadede kullanmak isterseniz bunu aşağıdaki şekilde yapabilirsiniz:
Kotlin
class Presenter { fun onSaveClick(view: View, task: Task){} }
Java
public class Presenter { public void onSaveClick(View view, Task task){} }
android:onClick="@{(theView) -> presenter.onSaveClick(theView, task)}"
Bir lambda ifadesini birden fazla parametreyle de kullanabilirsiniz:
Kotlin
class Presenter { fun onCompletedChanged(task: Task, completed: Boolean){} }
Java
public class Presenter { public void onCompletedChanged(Task task, boolean completed){} }
<CheckBox android:layout_width="wrap_content" android:layout_height="wrap_content"
android:onCheckedChanged="@{(cb, isChecked) -> presenter.completeChanged(task, isChecked)}" />
Dinlediğiniz etkinlik, türü void
olmayan bir değer döndürürse ifadelerinizin de aynı türde değeri döndürmesi gerekir. Örneğin, dokunup basılı tutma (uzun tıklama) etkinliğini dinlemek istiyorsanız ifadenizin bir boole döndürmesi gerekir.
Kotlin
class Presenter { fun onLongClick(view: View, task: Task): Boolean { } }
Java
public class Presenter { public boolean onLongClick(View view, Task task) { } }
android:onLongClick="@{(theView) -> presenter.onLongClick(theView, task)}"
İfade null
nesneler nedeniyle değerlendirilemezse veri bağlama, söz konusu tür için varsayılan değeri döndürür. Örneğin, başvuru türleri için null
, int
için 0
veya boolean
için false
.
Yüklem içeren bir ifade kullanmanız gerekiyorsa (örneğin, üçlü) void
sembolünü simge olarak kullanabilirsiniz:
android:onClick="@{(v) -> v.isVisible() ? doSomething() : void}"
Karmaşık dinleyicilerden kaçının
Dinleyici ifadeleri güçlüdür ve kodunuzun daha kolay okunmasını sağlayabilir. Diğer yandan, karmaşık ifadeler içeren işleyiciler, düzenlerinizin okunmasını ve bakımını zor hale getirir. İfadeleriniz, mevcut verileri kullanıcı arayüzünden geri çağırma yönteminize iletmek kadar basit olmalıdır. Dinleyici ifadesinden çağırdığınız geri çağırma yönteminin içine herhangi bir iş mantığı uygulayın.
İçe aktarma işlemleri, değişkenler ve içerir
Veri Bağlama Kitaplığı'nda içe aktarmalar, değişkenler ve içermeler gibi özellikler sunulur. İçe aktarma işlemleri, düzen dosyalarınızda kolayca başvuru yapmanızı sağlar. Değişkenler, ifadelerde kullanılabilecek bir özelliği tanımlamanıza olanak tanır. Karmaşık düzenleri uygulamanızda yeniden kullanabilmenizi sağlar.
İçe aktarma işlemleri
İçe aktarma işlemleri, düzen dosyanızdaki (yönetilen kodda olduğu gibi) sınıflara referans vermenizi sağlar.
data
öğesi içinde sıfır veya daha fazla import
öğesi kullanabilirsiniz. Aşağıdaki kod örneği, View
sınıfını düzen dosyasına aktarır:
<data>
<import type="android.view.View"/>
</data>
View
sınıfını içe aktarmak, bağlama ifadelerinizden bu sınıfa başvuruda bulunmanıza olanak tanır.
Aşağıdaki örnekte View
sınıfının VISIBLE
ve GONE
sabit değerlerine nasıl referans verileceği gösterilmektedir:
<TextView
android:text="@{user.lastName}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:visibility="@{user.isAdult ? View.VISIBLE : View.GONE}"/>
Takma adlar yazın
Sınıf adı çakışmaları olduğunda, sınıflardan birinin adını bir takma ad olarak değiştirebilirsiniz. Aşağıdaki örnekte com.example.real.estate
paketindeki View
sınıfı Vista
olarak yeniden adlandırılmaktadır:
<import type="android.view.View"/>
<import type="com.example.real.estate.View"
alias="Vista"/>
Daha sonra, düzen dosyasında com.example.real.estate.View
referansı için Vista
ve android.view.View
öğesine referans vermek için View
öğesini kullanabilirsiniz.
Diğer sınıfları içe aktarma
İçe aktarılan türleri, değişkenlerde ve ifadelerde tür referansları olarak kullanabilirsiniz. Aşağıdaki örnekte, değişken türü olarak kullanılan User
ve List
gösterilmektedir:
<data>
<import type="com.example.User"/>
<import type="java.util.List"/>
<variable name="user" type="User"/>
<variable name="userList" type="List<User>"/>
</data>
Bir ifadenin bir kısmını yayınlamak için içe aktarılan türleri kullanabilirsiniz. Aşağıdaki örnek, connection
özelliğini User
türüne yayınlamaktadır:
<TextView
android:text="@{((User)(user.connection)).lastName}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
İfadelerde statik alanlara ve yöntemlere başvururken içe aktarılan türleri de kullanabilirsiniz. Aşağıdaki kod, MyStringUtils
sınıfını içe aktarır ve capitalize
yöntemine referans verir:
<data>
<import type="com.example.MyStringUtils"/>
<variable name="user" type="com.example.User"/>
</data>
…
<TextView
android:text="@{MyStringUtils.capitalize(user.lastName)}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
Yönetilen kodda olduğu gibi java.lang.*
de otomatik olarak içe aktarılır.
Değişkenler
data
öğesi içinde birden çok variable
öğesi kullanabilirsiniz. Her variable
öğesi, düzen dosyası içindeki bağlama ifadelerinde kullanılacak düzende ayarlanabilen bir özelliği tanımlar. Aşağıdaki örnekte user
, image
ve note
değişkenleri açıklanmaktadır:
<data>
<import type="android.graphics.drawable.Drawable"/>
<variable name="user" type="com.example.User"/>
<variable name="image" type="Drawable"/>
<variable name="note" type="String"/>
</data>
Değişken türleri, derleme zamanında incelenir. Bu nedenle, bir değişken Observable
kullanıyorsa veya gözlemlenebilir bir koleksiyon olursa bu türe yansıtılmalıdır. Değişken, Observable
arayüzünü uygulamayan bir temel sınıf veya arayüzse değişkenler gözlemmez.
Çeşitli yapılandırmalar için farklı düzen dosyaları (örneğin, yatay veya dikey) olduğunda değişkenler birleştirilir. Bu düzen dosyaları arasında çakışan değişken tanımları olmamalıdır.
Oluşturulan bağlama sınıfında, açıklanan değişkenlerin her biri için bir setter ve alıcı bulunur. Ayarlayıcı çağrılana kadar değişkenler, varsayılan yönetilen kod değerlerini alır. Örneğin, referans türleri için null
, int
için 0
, boolean
için false
vb.
Gerektiğinde bağlama ifadelerde kullanılmak üzere context
adlı özel bir değişken oluşturulur. context
değeri, kök görünümünün getContext()
yöntemindeki Context
nesnesidir. context
değişkeni, bu ada sahip açık bir değişken bildirimi tarafından geçersiz kılınır.
Şunları içerir:
Bir özellikte uygulama ad alanını ve değişken adını kullanarak değişkenleri, dahil edilen bir düzenin bağlamasına kapsayıcı düzenden aktarabilirsiniz. Aşağıdaki örnekte, name.xml
ve contact.xml
düzen dosyalarındaki user
değişkenleri gösterilmektedir:
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:bind="http://schemas.android.com/apk/res-auto">
<data>
<variable name="user" type="com.example.User"/>
</data>
<LinearLayout
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<include layout="@layout/name"
bind:user="@{user}"/>
<include layout="@layout/contact"
bind:user="@{user}"/>
</LinearLayout>
</layout>
Veri bağlama, birleştirme öğesinin doğrudan alt öğesi olarak "include"u desteklemez. Örneğin, aşağıdaki düzen desteklenmez:
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:bind="http://schemas.android.com/apk/res-auto">
<data>
<variable name="user" type="com.example.User"/>
</data>
<merge><!-- Doesn't work -->
<include layout="@layout/name"
bind:user="@{user}"/>
<include layout="@layout/contact"
bind:user="@{user}"/>
</merge>
</layout>
Ek kaynaklar
Veri bağlama hakkında daha fazla bilgi edinmek için aşağıdaki ek kaynaklara bakın.