Android - LiveData

LiveData ဆိုတာဘာလဲ?

LiveData ဆိုတာက Android Architecture Components ထဲမှာ ပါဝင်တဲ့ library တစ်ခုဖြစ်ပြီး data ပြောင်းလဲမှုတွေကို ကိုစောင့်ကြည့်နေနိုင်တဲ့ data holder တစ်ခုပါ။ LiveData က သူတစ်ခုထဲ သီးသန့် ရပ်တည်နေတာမဟုတ်ဘဲ data တစ်ခုရဲ့ ပြောင်းလဲမှုတွေကို စောင်ကြည့်ဖို့အတွက် သုံးတာဖြစ်ပါတယ်။
ဥပမာ String data type တစ်ခုရဲ့ changes တွေကို စောင့်ကြည့်မယ်ဆိုရင် LiveData<String> ဆိုတဲ့ ပုံစံမျိုးနဲ့ သုံးပေးရပါတယ်။

LiveData ကို ဘယ်လိုနေရာတွေမှာသုံးလဲ?

LiveData ကို Android Architecture Components တွေဖြစ်တဲ့ ViewModel တို့ Room တို့နဲ့ တွဲသုံးလေ့ရှိပါတယ်။
Room persistence library က database ထဲကနေ data ဆွဲထုတ်တဲ့အခါမှာ record တစ်ခုချင်းထုတ်ရင် Entity တစ်ခု return ပြန်ပေးပြီး record အစုလိုက်ထုတ်တဲ့အခါမှာ List နဲ့ return ပြန်ပေးပါတယ်။ အဲ့လို data select လုပ်တဲ့အခါမှာ data ထုတ်ရတဲ့ ကြာချိန်ရှိပါတယ်။ အဲ့လိုကြာချိန်ရှိတဲ့အတွက် data ထုတ်တဲ့ process ကို main thread ပေါ်မှာ ရေးထားရင် data ထုတ်လို့မပြီးမချင်း UI က ရပ်နေမှာ ဖြစ်တဲ့အတွက် Room က main thread ပေါ်မှာ အလုပ်ပေးမလုပ်ပါဘူး။ AsyncTask သုံးပြီး background thread မှာ run ပေးရပါတယ်။
ထုတ်ထားတဲ့ data ကလဲ ထုတ်ပြီးတဲ့အချိန်မှာ data ပြောင်းလဲသွားတာမျိုးရှိခဲ့ရင် နောက်တစ်ခေါက် AsyncTask ကို manual ပြန် run ပေးမှ ပြောင်းသွားတဲ့ data ကို ရမှာပါ။

အဲ့လိုကိစ္စတွေကို ကျော်လွှားချင်ရင် LiveData ကို သုံးလို့ရပါတယ်။
Room က LiveData ကို direct support ပေးတဲ့အတွက် ပုံမှန် data select လုပ်ရင် Entity သို့မဟုတ် List ဆိုပြီး return ပြန်တဲ့နေရာမှာ LiveData သို့မဟုတ် LiveData<List> ဆိုပြီး return ပြန်ပေးလို့ရပါတယ်။
အဲ့လို return ပြန်လာတဲ့ LiveData ကို AsyncTask သုံးစရာမလိုပဲ observe လုပ်ပေးလိုက်တာနဲ့ Entity တွေကို တိုက်ရိုက်သုံးလို့ရပြီဖြစ်ပါတယ်။
Observe လုပ်ထားတဲ့အတွက် data select လုပ်ပြီးတော့မှ database ထဲကို data အသစ်ဝင်လာရင် ဖြစ်စေ data update ဖြစ်သွားရင် ဖြစ်စေ LiveData ကချက်ချင်း data အသစ်ကို Observer ဆီ return ပြန်ပေးပါတယ်။ အဲ့လို return ပြန်ပေးနေတဲ့အတွက် Database ထဲမှာ data တစ်ခုခု ပြောင်းလဲသွားတိုင်း UI မှာ realtime update ဖြစ်နေမှာပါ။

LiveData ကို ဘယ်လိုသုံးမလဲ?

LiveData သုံးဖို့အတွက် ဒါ library လေးကို gradle dependencies ထဲမှာ ထည့်ပေးရပါမယ်။

dependencies {
     implementation "android.arch.lifecycle:extensions:1.1.1"
}

အရင်နေ့က Room အကြောင်း တင်ပေးထားတဲ့ post ထဲက sample ကို ဆက်သုံးသွားပါမယ်။
Room persistence library အကြောင်း မဖတ်ရသေးရင် ဒီမှာ သွားကြည့်ပေးပါ။

Room ရှင်းပြတဲ့ထဲက BookDao မှာ data select လုပ်တဲ့ method ၂ ခုကို LiveData return ပြန်ဖို့ အရင် ပြင်ရပါမယ်။

@Dao
public interface BookDao {
    // returns book list as LiveData
    @Query("SELECT * from books")
    LiveData<List<BookEntity>> getAllBooks();

    // returns book as LiveData
    @Query("SELECT * from books where id = :bookId")
    LiveData<BookEntity> getBook(int bookId);

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    void addBook(BookEntity bookEntity);

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    void addBooks(List<BookEntity> bookEntities);

    @Query("DELETE from books")
    void deleteAllBooks();
}

ပြီးရင် ExampleActivity မှာ AsyncTask ကို ဖြုတ်ပြီးတော့ LiveData ကိုပဲ သုံးရုံပါပဲ

public class ExampleActivity extends AppCompatActivity {
    private List<BookEntity> bookList;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.example);

        // BookDao ကနေ getAllBooks method ကို ခေါ်လိုက်ရင် book list ပါဝင်တဲ့ LiveData ရပါတယ်။
        LiveData<List<BookEntity>> liveBookList = AppDatabase.getInstance(this).bookDao().getAllBooks();

        // အဲ့ဒီ LiveData ကို observe လုပ်ရပါတယ်။
        liveBookList.observe(ExampleActivity.this, new Observer<List<BookEntity>>() {
            @Override
            public void onChanged(@Nullable List<BookEntity> bookEntities) {
                bookList = bookEntities;
            }
        });        
    }
}

အဲ့ဒီ LiveData ကို Observer ဆောက်ပေးလိုက်တာနဲ့ Database ထဲက book list အသစ်တိုးလာရင်ဖြစ်စေ data ပြောင်းလဲမှုရှိရင် ဖြစ်စေ onChanged method ကို လာခေါ်တဲ့အတွက် book list က အမြဲတမ်း နောက်ဆုံး/အသစ်လွင်ဆုံး data တွေပဲရှိနေမှာဖြစ်ပါတယ်။
LiveData က Android activity ရဲ့ LifeCycle ကိုလဲ အလိုလျောက်စောင့်ကြည့်ပေးနေတဲ့အတွက် LiveData ကို Observe လုပ်နေတဲ့ Observer က ဒီ Activity က active မဖြစ်တော့တာနဲ့ Observe လုပ်နေခြင်းကို အလိုလျောက် ရပ်ပေးတဲ့အတွက် memory leak တွေကိုလဲ ကာကွယ်ပေးနိုင်ပါတယ်။

LiveData ကို Room က ရတဲ့ data အတွက်ပဲမဟုတ်ဘဲ မိမိလိုအပ်သလို data ထည့်ပေးပြီးတော့ တစ်ဖက်မှာ ပြန်ပြီး observe လုပ်နိုင်အောင်လဲ ရေးလို့ရပါတယ်။ အဲ့ဒါကိုတော့ ဒီ medium post မှာ ဆက်လက်လေ့လာနိုင်ပါတယ်။

Android Architecture Components တွေဖြစ်တဲ့ DataBinding, ViewModel, LiveData, Room စတာတွေကို အသုံးပြုထားတဲ့ Sample Project ကို https://gitlab.com/anntphyothwin/android-archi-sample မှာ လေ့လာနိုင်ပါတယ်။

Sign In or Register to comment.