Düzenler ve bağlama ifadeleri

İ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 kodda örnek bir düzen dosyası gösterilmektedir:

<?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 açıklar:

<variable name="user" type="com.example.User" />

Düzen içindeki ifadeler, özellik özelliklerinde @{} 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ı açıklayan düz bir nesnenizin olduğunu varsayalım:

data class User(val firstName: String, val lastName: String)

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 daha sonra hiç değişmemesi yaygın bir durumdur. Aşağıdaki örnekte gösterildiği gibi, Java programlama dilinde erişimci yöntemlerini kullanma gibi bir dizi kuralı izleyen bir nesnenin kullanılması da mümkündür:

// Not applicable in Kotlin.
data class User(val firstName: String, val lastName: String)

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, 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, ikinci sınıftaki getFirstName() yöntemine erişir. Ayrıca, 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ı, Binding soneki eklenmiş ve Pascal harfine dönüştürülen düzen dosyasının adına dayanı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 özelliklerinden düzenin görünümlerine yönelik tüm bağlamaları (ör. user değişkeni) barındırır ve bağlama ifadeleri için nasıl değer atanacağını bilir. Aşağıdaki örnekte gösterildiği gibi, düzeni genişletirken bağlamaları oluşturmanızı öneririz:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val binding: ActivityMainBinding = DataBindingUtil.setContentView(
            this, R.layout.activity_main)

    binding.user = User("Test", "User")
}

@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österir. Alternatif olarak görünümü aşağıdaki örnekte gösterildiği gibi bir LayoutInflater kullanarak alabilirsiniz:

val binding: ActivityMainBinding = ActivityMainBinding.inflate(getLayoutInflater())

ActivityMainBinding binding = ActivityMainBinding.inflate(getLayoutInflater());

Fragment, ListView veya RecyclerView bağdaştırıcısı içinde 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:

val listItemBinding = ListItemBinding.inflate(layoutInflater, viewGroup, false)
// or
val listItemBinding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false)

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 benziyor. İfade dilinde aşağıdaki operatörleri ve anahtar kelimeleri kullanabilirsiniz:

• Matematiksel: + - / * %
• Dize birleştirme: +
• Mantıksal: && ||
• İkili program: & | ^
• Birli: + - ! ~
• Üst karakter: >> >>> <<
• Karşılaştırma: == > < >= <= (< öğesinin < olarak değiştirilmesi gerekir)
• instanceof
• Gruplandırma: ()
• Dize, sayısal ve null gibi hazır değerler
• Cast
• 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 eksik:

• this
• super
• new
• Açık 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}"

Tesis referansları

Bir ifade, aşağıdaki biçimi kullanarak sınıftaki bir özelliğe başvuruda bulunabilir. Bu biçim alanlar, getter'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 boşsa user.name değerine null varsayılan değeri atanır. Yaşın int türünde olduğu user.age için başvuruda bulunuyorsanız 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 ID ile referans verebilir:

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&lt;String>"/>
    <variable name="sparse" type="SparseArray&lt;String>"/>
    <variable name="map" type="Map&lt;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]}"

Ayrıca object.key gösterimini kullanarak haritadaki bir değere başvuruda bulunabilirsiniz. Örneğin, önceki örnekte verilen @{map[key]} değerini @{map.key} ile değiştirebilirsiniz.

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"]}'

Özellik değerini başına ve sonuna da çift tırnak içinde girebilirsiniz. Bu sırada dize değişmez değerleri, burada gösterildiği gibi vurgu işaretleri ` ile çevrili olmalıdır:

android:text="@{map[`firstName`]}"

Kaynaklar

Bir ifade, uygulama kaynaklarına aşağıdaki söz dizimiyle başvurabilir:

android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"

Biçim dizelerini ve çoğul hallerini 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:

Olay işleme

Veri bağlama, görünümlerden gönderilen ifade işleme etkinliklerini (örneğin, 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, onClick() yöntemine sahiptir. Dolayısıyla bu etkinliğin özelliği android:onClick şeklindedir.

Çakışmayı önlemek için tıklama etkinliğinde android:onClick dışında bir özelliğe ihtiyaç duyan bazı özel etkinlik işleyiciler vardır. Bu tür çakışmalardan kaçınmak için aşağıdaki özellikleri kullanabilirsiniz:

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, dinleyici yönteminin imzasına uygun yöntemlere başvurabilirsiniz. Bir ifade bir yöntem referansına dönüştüğünde, veri bağlama, yöntem referansını ve sahip nesnesini bir işleyicide 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 bir null işleyicisi ayarlar.
• Dinleyici bağlamaları: Etkinlik gerçekleştiğinde değerlendirilen lambda ifadeleridir. Veri bağlama her zaman görünümde ayarlanan bir işleyici oluşturur. Etkinlik gönderildiğinde, işleyici lambda ifadesini değerlendirir.

Yöntem referansları

android:onClick'i etkinlikteki bir yönteme atadığınız 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 imzası yanlışsa derleme zamanı hatası alırsınız.

Yöntem referansları ile işleyici bağlamaları arasındaki en büyük fark, gerçek işleyici uygulamasının etkinlik tetiklendiğinde değil, veri 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şleyicisine atamak için normal 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 ele alalım:

class MyHandlers {
    fun onClickFriend(view: View) { ... }
}

public class MyHandlers {
    public void onClickFriend(View view) { ... }
}

Bağlama ifadesi, bir görünüm için tıklama işleyiciyi aşağıdaki şekilde 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>

Dinleyici bağlamaları

İşleyici bağlamaları, bir etkinlik gerçekleştiğinde çalışan bağlayıcı ifadelerdir. Bunlar, yöntem referanslarına benzer ancak rastgele veri bağlama ifadelerini çalıştırmanıza olanak tanır. Bu özellik, Android Gradle Plugin for Gradle sürüm 2.0 ve üzeri 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ğeriniz işleyicinin beklenen dönüş değeriyle eşleşmelidir. Örneğin, onSaveClick() yöntemine sahip aşağıdaki sunucu sınıfını ele alalım:

class Presenter {
    fun onSaveClick(task: Task){}
}

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 etkinlik için 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) işlevine geçirilen view parametresi tanımlanmamıştır. İşleyici bağlamaları, işleyici parametreleri için iki seçenek sunar: 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:

class Presenter {
    fun onSaveClick(view: View, task: Task){}
}

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:

class Presenter {
    fun onCompletedChanged(task: Task, completed: Boolean){}
}

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 isterseniz ifadeniz bir boole döndürmelidir.

class Presenter {
    fun onLongClick(view: View, task: Task): Boolean { }
}

public class Presenter {
    public boolean onLongClick(View view, Task task) { }
}

android:onLongClick="@{(theView) -> presenter.onLongClick(theView, task)}"

İfade, null nesneleri nedeniyle değerlendirilemezse veri bağlama, o tür için varsayılan değeri döndürür (ör. referans 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ü) sembol olarak void kullanabilirsiniz:

android:onClick="@{(v) -> v.isVisible() ? doSomething() : void}"

Karmaşık işleyicilerden kaçının.

İşleyici ifadeleri güçlüdür ve kodunuzun okunmasını kolaylaştırabilir. Öte yandan, karmaşık ifadeler içeren işleyiciler, düzenlerinizin okunmasını ve bakımını zorlaştırır. İfadelerinizin, mevcut verileri kullanıcı arayüzünden geri çağırma yönteminize iletmek kadar basit olmasını sağlayın. İşleyici ifadesinden çağırdığınız geri çağırma yönteminin içine herhangi bir iş mantığı uygulayın.

İçe aktarmalar, değişkenler ve içerir

Veri Bağlama Kitaplığı; içe aktarmalar, değişkenler ve içermeler gibi özellikler sunar. İçe aktarma işlemleri, düzen dosyalarınız içinde kolayca başvuru yapabileceğiniz sınıflardır. Değişkenler, bağlama ifadelerinde kullanılabilecek bir özelliği açıklamanızı sağlar. Uygulamanızda karmaşık düzenleri yeniden kullanmanıza olanak tanır.

İçe Aktarımlar

İçe aktarma işlemleri, yönetilen kodda olduğu gibi düzen dosyanızdaki sınıflara referans vermenizi sağlar. data öğesinin 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 sabitlerine 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 adla yeniden adlandırabilirsiniz. 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 öğesine ve View öğesine referans vermek için android.view.View öğesini kullanabilirsiniz.Vista

Diğer sınıfları içe aktarma

İçe aktarılan türleri, değişkenlerde ve ifadelerde tür referansı 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&lt;User>"/>
</data>

Bir ifadenin parçasını yayınlamak için içe aktarılan türleri kullanabilirsiniz. Aşağıdaki örnekte connection özelliği User türüne dönüştürülü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 de içe aktarılan türleri kullanabilirsiniz. Aşağıdaki kod, MyStringUtils sınıfını içe aktarır ve onun 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 öğesinin içinde birden fazla 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 tanımlanmaktadı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 özelliğini uygular veya gözlemlenebilir bir koleksiyon olursa türe yansıtılması gerekir. Değişken, Observable arayüzünü uygulamayan bir temel sınıf veya arayüzse değişkenler gözlemlenmez.

Çeşitli yapılandırmalar için farklı düzen dosyaları (ör. 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. Değişkenler, ayarlayıcı çağrılana kadar 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 ifadelerinde kullanılmak üzere context adlı özel bir değişken oluşturulur. context değeri, kök görünümü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.

İçerik

Bir özellikte uygulama ad alanını ve değişken adını kullanarak değişkenleri, dahil edilen düzenin bağlamasına kapsayıcı düzenden aktarabilirsiniz. Aşağıdaki örnekte name.xml ve contact.xml düzen dosyalarından dahil edilen 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 olan "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>