> For the complete documentation index, see [llms.txt](https://moeindeveloper.gitbook.io/maad/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://moeindeveloper.gitbook.io/maad/mvvmsimpleexample.md).

# مثالی ساده

بابت تاخیر عذرخواهی می کنم.

## فیلم در آپارات:

{% embed url="<https://www.aparat.com/v/8O1NG>" %}

## توضیحات:

پیروی قسمت های قبلی، مثالی ساده از این معماری جذاب می زنیم.

کلاس های مربوطه را در **پکیج** های ساخته شده بسازید:

|  Package  |     Class     |
| :-------: | :-----------: |
|   Model   |  MainModel.kt |
| ViewModel | MainViewModel |

بعد از ساخت این کلاس ها، به یک **دیتاکلاس(DataClass)** نیاز داریم که اطلاعات را در آن قرار بدهیم و از آن ها استفاده کنیم؛ پس ابتدا یک پکیج به نام **DataSource** بسازید و سپس درون آن کلاس **NameModel** را بسازید.

{% hint style="warning" %}
***نکته مهم***: **NameModel** از نوع **دیتامدل** می باشد و با مدلی که برای معماری **MVVM** استفاده می شود فرق دارد!
{% endhint %}

کلاس **NameModel**:&#x20;

```kotlin
package moeindeveloper.kotlinmvvm.DataSource

data class NameModel(val name: String)
```

همانطور که می بینید، کلاس ما دارای یک مشخصه به نام **name** است و قرار است که **name** را نمایش دهیم.&#x20;

نکته: در کلاس **NameModel** شاهد قدرت کاتلین هستیم که چگونه روند توسعه اپلیکیشن های اندرویدی را لذت بخش تر می کند! کد جاوای کلاس **NameModel**:

```java
public final class NameModel {
   @NotNull
   private final String name;

   @NotNull
   public final String getName() {
      return this.name;
   }

   public NameModel(@NotNull String name) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
      this.name = name;
   }

   @NotNull
   public final String component1() {
      return this.name;
   }

   @NotNull
   public final NameModel copy(@NotNull String name) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      return new NameModel(name);
   }

   // $FF: synthetic method
   @NotNull
   public static NameModel copy$default(NameModel var0, String var1, int var2, Object var3) {
      if ((var2 & 1) != 0) {
         var1 = var0.name;
      }

      return var0.copy(var1);
   }

   @NotNull
   public String toString() {
      return "NameModel(name=" + this.name + ")";
   }

   public int hashCode() {
      return this.name != null ? this.name.hashCode() : 0;
   }

   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof NameModel) {
            NameModel var2 = (NameModel)var1;
            if (Intrinsics.areEqual(this.name, var2.name)) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }
}
```

قضاوت با شما🤓

## ساخت کلاس مدل Model:

کلاس **MainModel** را باز کنید و شروع کنید:

```kotlin
class MainModel{
}
```

در پایین کلاس **MainModel** یک **اینترفیس** نیز بسازید:

```kotlin
interface MainModelCallback{
}
```

فایل **MainModel** به صورت کلی:

```kotlin
class MainModel{
}

interface MainModelCallback{
}
```

حال برای انتقال اطلاعات نیاز به یک **فانکشن** داریم که وقتی اطلاعات آماده شد، آن را به ***ویومدل*** تحویل بدهد؛ اطلاعات ما آرایه ای از نوع **NameModel** می باشد.

پس درون **اینترفیس** خود به این صورت عمل کنید:

```kotlin
fun onDataFetched(names: ArrayList<NameModel>)
```

و در نهایت به این صورت خواهد شد:

```kotlin
interface MainModelCallback{
    fun onDataFetched(names: ArrayList<NameModel>)
}
```

در کلاس ***مدل*** خود نیاز داریم که اطلاعات را فراخوانی کنیم، در این صورت از اطلاعات ساختی استفاده خواهیم کرد. ***فانکشن*** ***لود*** کردن اطلاعات را به این صورت بنویسید:

```kotlin
fun loadData(mainModelCallback: MainModelCallback){
    }
```

در اینجا برای ورودی ***فانکشن*** خود، از ***اینترفیسی*** که ساختیم استفاده می کنیم و از طریق آن، هنگامی که اطاعات آماده شد، آن ها را به ***ویومدل*** انتقال می دهیم.

برای شبیه سازی، ما می خواهیم بعد از سه ثانیه، اطلاعات را انتقال دهیم، برای این کار به این صورت عمل کنید:

```kotlin
Handler().postDelayed({
            //insert your code here
        },3000)
```

سپس درون **براکت** یک **آرایه** بسازید و چندین عضو به آن اضافه کنید:

```kotlin
val list = ArrayList<NameModel>()
            list.add(NameModel("moein"))
            list.add(NameModel("Mahdi"))
            list.add(NameModel("Amir"))
            list.add(NameModel("Mohammad"))
```

و حالا آن را به ***اینترفیس*** خود پاس بدهید:

```kotlin
mainModelCallback.onDataFetched(list)
```

***فانکشن*** شما در نهایت:

```kotlin
fun loadData(mainModelCallback: MainModelCallback){
        Handler().postDelayed({
            val list = ArrayList<NameModel>()
            list.add(NameModel("moein"))
            list.add(NameModel("Mahdi"))
            list.add(NameModel("Amir"))
            list.add(NameModel("Mohammad"))
            mainModelCallback.onDataFetched(list)
        },3000)
    }
```

تبریک میگم! شما مدل خود را ساختید:

```kotlin
import android.os.Handler
import moeindeveloper.kotlinmvvm.DataSource.NameModel

class MainModel{
    fun loadData(mainModelCallback: MainModelCallback){
        Handler().postDelayed({
            val list = ArrayList<NameModel>()
            list.add(NameModel("moein"))
            list.add(NameModel("Mahdi"))
            list.add(NameModel("Amir"))
            list.add(NameModel("Mohammad"))
            mainModelCallback.onDataFetched(list)
        },3000)
    }
}

interface MainModelCallback{
    fun onDataFetched(names: ArrayList<NameModel>)
}
```

## ساخت کلاس ViewModel:

مثل کلاس مدل عمل خواهیم کرد:

```kotlin
class MainViewModel{
}

interface MainViewModelCallback{
}
```

در اینجا برای انتقال اطلاعات به ویو نیز به یک اینترفیس نیاز داریم. پس اینترفیس MainViewModelCallback را قرار می دهیم.

در اینترفیس MainViewModelCallBack یک فانکشن به صورت زیر ایجاد کنید:

```kotlin
fun onDataFetched(names: ArrayList<NameModel>)
```

و در آخر باید به این صورت باشد:

```kotlin
interface MainViewModelCallback{
    fun onDataFetched(names: ArrayList<NameModel>)
}
```

حالا ما نیاز داریم که از طریق ویومدل، اجزای ویو مثلا پراگرس بار و... را کنترل کنیم! پس از درون ویومدل یک متغیر منطقی (boolean) را تشکلیل دهید:

```kotlin
var isLoading = ObservableField<Boolean>(false)
```

مختصری از [ObservableField](https://developer.android.com/reference/android/databinding/ObservableField):

بخشی از کتابخانه [DataBinding](https://developer.android.com/topic/libraries/data-binding/) است که میتوان از طریق آن بر روی اطلاعات bind شده نظارت داشت!

حالا باید از MainModelCallback درون MainViewModel استفاده کنیم پس آن را Implement می کنیم: به این صورت:

```kotlin
class MainViewModel: MainModelCallback
```

بعد از این کار، شما باید متود های داخل اینترفیس را نیز Implement کنید:

```kotlin
override fun onDataFetched(names: ArrayList<NameModel>) {
    }
```

حالا کلاس شما باید اینگونه باشد:

```kotlin

class MainViewModel: MainModelCallback{

    var isLoading = ObservableField<Boolean>(false)

    override fun onDataFetched(names: ArrayList<NameModel>) {
        
    }
}
```