Data Binding 前置準備

 

版本限制

Data Binding 函式庫提供靈活性和廣泛的兼容性，目前可運行在 Android 4.0( API Level 14)以及更高的版本，以及建議使用最新的 Android Gradle 插件，Data Binding 可以運作在 1.5.0 及更高的版本

 

相依性

要啟用 Data Binding 函式庫，必須在 app module 的 build.gradle 檔案加入以下內容

android {  
      ...  
    
      dataBinding {  
          enabled = true  
      }  
  }

 

Android Studio 支援特性

Android Studio 提供以下關於 Data Binding 的特性

1.語法高亮

2.標示語法錯誤

3.XML 代碼自動完成

 

新型資料綁定編譯器(data binding compiler)

Android Gradle 3.1.0-alpha06 版本包含新型資料綁定編譯器，該編譯器能更快速的產生綁定類別(binding class)。

使用舊型資料綁定編譯器可能會產生多個錯誤訊息並提示找不到綁定類別，而使用新型資料綁定編譯器可避免這些狀況。

透過在 gradle.properties 檔案設定以下內容以啟用新型資料綁定編譯器

android.databinding.enableV2=true

 

Note:

注意 Android Studio 3.1 還未完全支援新型資料綁定編譯器，而 Android Studio 3.2 預設已支援新型資料綁定編譯器。

---

Orignal From: Data Binding 前置準備

Read more »

Data Binding (Android Jetpack)

 

什麼是 Data Binding

Data Binding 是一個函式庫，允許您使用聲明性格式(而不是以編程方式)將佈局(layout)中的 UI 組件綁定到應用程序中的數據來源。

 

使用編程方式綁定

佈局元件(layout)通常會定義在 Activity 內並呼叫相關的 UI 框架方法。
如下透過呼叫 findViewById 找到 TextView並綁定到 viewModel 的 userName 屬性

TextView textView = findViewById(R.id.sample_text);  
    
  textView.setText(viewModel.getUserName());

 

 

使用 Data Binding 綁定

以下則是使用 Data Binding 直接在佈局檔案指定文字給 widget，這種方式可以取代上面範例的 Java code

<TextView  
      android:text="@{viewmodel.userName}" />

透過在佈局檔案中綁定元件的方式可以移除許多需要在 Activity 呼叫的 UI 框架方法。讓  Activity 更簡潔並容易維護，也能改善效能，避免記憶體洩漏及 Null Pointer Exception。

 

Using the Data Binding Library

1.前置準備

2.佈局(layout)和綁定表達式(binding expressions)

3.使用可觀察資料物件(observable data objects)

4.產生綁定類別(binding classes)

5.綁定轉接器(binding adapters)

6.綁定佈局到架構元件(architecture components)

7.雙向綁定(Two-way data binding)

 

---

Orignal From: Data Binding (Android Jetpack)

Read more »

Lifecycle-Aware Components

什麼是 Lifecycle-aware Components?

Lifecycle-ware components(生命週期感知元件)包含在 android.arch.lifecycle 套件中，基本上就是當元件(Activity or Service)的生命週期發生變化時，生命週期元件即會自動收到通知並觸發相對應的動作。

 

為什麼需要生命週期感知元件?

在此之前若開發者需要根據元件的生命週期執行相對應的動作時都必須寫在元件的對應方法中。最常見的例子為旋轉螢幕時需要儲存資料，不是寫在 onPause 方法就是寫在 onSaveInstanceState 方法。

但這種寫法最直接的缺點就是增加 Activity 的大小，讓 Activity 變得越來越大。

生命週期感知元件可以根據 Activity 或 Fragment 的當前生命週期狀態自動呼叫其行為。

 

Lifecycle

Lifecycle 是一個類別，擁有關於另一個元件(Activity or Fragment)生命週期狀態的資訊。
Lifecycle 使用 2 個列舉來追蹤其相關連元件的生命週期狀態:

1.Event(事件)

Event 透過 Framework 和 Lifecycle class 發送，Event 會對應於 Activity 或 Fragment 的回調事件(callback events)。

2.State(狀態)

相關連元件的當前狀態。

LifecycleOwner

LifecycleOwner 為只有一個方法的介面，該方法必須回傳 Lifecycle。

在 Support Library 26.1.0 已將 Activity 和 Fragment 繼承 LifecycleOwner 並寫好回傳 Lifecycle 的實作部分，也就是說 Activity 和 Fragment 就是 LifecycleOwner。

要自動感知 Activity 的生命週期，首先呼叫 getLifecycle 方法取得 Lifecycle，接著再呼叫 Lifecycle 的 addObserver 方法讓 LifecycleObserver 訂閱 Lifecycle。

基本上就是透過 LifecycleOwner 提供 Lifecycle，接著讓 LifecycleObserver 訂閱
Lifecycle，如此 LifecycleObserver 就能感知 Lifecycle 的變化。

 

LifecycleObserver

LifecycleObserver 的用途就是用來跟蹤繼承 LifecycleOwner 的元件，透過在方法上加上註解的方式，可以自動取得目標元件的相關生命週期變化。

一個最簡單用來感知 Activity 的 LifecycleObserver 如下

import android.arch.lifecycle.Lifecycle;  
  import android.arch.lifecycle.Lifecycle.Event;  
  import android.arch.lifecycle.LifecycleObserver;  
  import android.arch.lifecycle.OnLifecycleEvent;  
  import android.content.Context;  
  import android.util.Log;  
    
  public class LifecycleMainActivityObserver implements LifecycleObserver {  
    
    private static final String TAG = LifecycleMainActivityObserver.class.getSimpleName();  
    
    @OnLifecycleEvent(Event.ON_START)  
    public void lifecycleStart() {  
      Log.d(TAG, "detect lifecycle on start");  
    }  
    
    @OnLifecycleEvent(Event.ON_CREATE)  
    public void lifecycleCreate() {  
      Log.d(TAG, "detect lifecycle on create");  
    }  
    
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)  
    public void lifecycleResume() {  
      Log.d(TAG, "detect lifecycle on resume");  
    }  
    
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)  
    public void lifecyclePause() {  
      Log.d(TAG, "detect lifecycle on pause");  
    }  
    
    @OnLifecycleEvent(Event.ON_STOP)  
    public void lifecycleStop() {  
      Log.d(TAG, "detect lifecycle on stop");  
    }  
    
    @OnLifecycleEvent(Event.ON_DESTROY)  
    public void lifecycleDestroy() {  
      Log.d(TAG, "detect lifecycle on destroy");  
    }  
    
    
    @OnLifecycleEvent(Event.ON_ANY)  
    public void lifecycleChange() {  
      Log.d(TAG, "detect lifecycle change");  
    }  
  }  
  

註解 OnLifecycleEvent(Event.ON_CREATE) 就表示當目標元件處於 create 狀態時，該方法便會被呼叫。

接著只要在目標元件的 onCreate 方法初始化 observer，並呼叫 addObserver() 即可

public class LifecycleMainActivity extends AppCompatActivity {  
    
    private LifecycleMainActivityObserver mLifecycleMainActivityObserver;  
    
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
      super.onCreate(savedInstanceState);  
      setContentView(R.layout.lifecycle_main_activity);  
    
      mLifecycleMainActivityObserver = new LifecycleMainActivityObserver();  
      getLifecycle().addObserver(mLifecycleMainActivityObserver);  
    }  
  }  
  

最後 LifecycleMainActivityObserver 的方法便會對應 LifecycleMainActivity 的生命週期改變自動被呼叫。

 

關於生命感知週期元件的最佳實踐

1.保持 UI Controllers(Activity or Fragment)盡量精簡，它們不該存取自己的資料，而應該交由 ViewModel 來執行，並透過 LiveData 將資料的變更反射回 View。

2.嘗試實作數據驅動的 UI，其中 UI Controller 負責在數據更改時更新視圖，或將用戶操作通知給 ViewModel。

3.應該將數據邏輯放到 ViewModel，把 ViewModel 當作 UI 和其他元件的連接器且 ViewModel 不應該去直接獲取數據(如本地端資料庫，遠端網路)。而是透過其它元件來取得數據，再返回給 UI controller。

4.使用 Data Binding 來建立 View 和 UI Controller 之間的簡潔介面，可讓 View 更具聲明性並盡量的減少在 Activity 和 Fragment 需要寫的代碼。也可以考慮使用 Butter Knife 來避免樣版代碼以及建立良好的抽象。

5.若 UI 非常複雜可以考慮建立 Presenter 來處理UI的變化。

6.不要在 ViewModel 中引用 View 或 Activity context，否則可能造成記憶體洩漏。

 

生命感知週期的使用案例

1.動畫，當 App 位於後台時停止動畫，返回前台時恢復動畫

2.網路連接，當 App 位於後台時暫停網路，返回前台時恢復網路

3.視頻緩衝，當 App 啟動時盡快啟動緩衝，但直到App完全啟動時再播放視頻。可在App銷毀時終止視頻緩衝。

4.位置更新，當 App 位於後台時使用粗粒度位置更新，返回前台時使用細粒度位置更新。

 

---

Orignal From: Lifecycle-Aware Components

Read more »

Android Architecture Components

什麼是 Android Architecture Components

Android Architecture Components(AAC) 是函式庫的集合，可以幫助開發者寫出穩健，可測試，維護性高的 App。

 

AAC 包含了以下函式庫

Data Binding		Lifecycles		LiveData		Navigation		Paging
將可觀察資料綁定到UI元件		管理Activity和Fragment 生命週期		當資料改變時通知視圖(View)		處理App導航功能		循序的從數據來源讀取資料
Room		ViewModel		WorkManager
流暢存取SQLite		以生命週期方式管理UI相關資料		管理後台任務

 

也可以看到 AAC 涵蓋了App的整個架構主體。

基本上有以下4個要點

1. lifecycle-aware components 管理 Activity 或 Fragment 的生命週期。

可以避免記憶體洩漏(memory leaks)，減少處理配置變更(configuration changes)的成本，更簡易的讀取資料到 UI。

2. LiveData 建立資料物件，當資料改變時會自動通知視圖(Views)。

可以套用 Observer Pattern 的觀念，把 LiveDate 當作 Subject，視圖當作 observer。
視圖會訂閱 LiveData，因此當 LiveData的資料發生變化時，視圖會自動收到通知。

3. ViewModel 保存 UI 相關的資料，讓 App 旋轉螢幕時不會銷毀資料。

ViewModel 就是擔任 MVVM Pattern 的 VM 角色，透過隔離視圖邏輯和數據層邏輯，方便撰寫測試，專注業務邏輯。

4. Room 能更快速的存取資料庫(SQLite)並可搭配 RxJava 協同使用。

Room 為 ORM 的一種，和其它流行的框架類似能夠大量簡化 SQL 語法。

 

---

Orignal From: Android Architecture Components

Read more »

Android Jetpack (噴射背包!!!) 簡介

什麼是 Android Jetpack?

Android Jetpack 是一系列軟體元件的組合，透過應用這些元件可以幫助您寫出最佳實踐，避免樣板代碼並簡化複雜任務，讓開發者專注於需要關心的代碼。

Jetpack 包含在 androidx.* 的套件名稱，沒有和任何平台 API 綁定，它向後相容並可頻繁更新，代表開發者可以隨時使用最新最好的版本。

 

使用 Jetpack 的好處

1.加速開發

Jetpack 元件可單獨或組合使用，同時利用 Kotlin 提供的特性來加速開發

2.消除樣板代碼

Jetpack 特別用來管理複雜的行為，如後台任務，導航，生命週期。讓您專注在需要關心的部分

3.建立高品質，穩固的 App

Jetpack 可以減少崩潰，減少記憶體洩漏並提供向後兼容性

 

Android Jetpack 元件組

主要有 4 個分類，每個分類都包含不同數量的元件，各個元件提供特定的功能，各為 Fundation , Architecture , Behavior , UI

1.Foundation

提供向後兼容，支援 Kotlin，測試相關功能

AppCompat		Android KTX		Multidex		Test
為舊版 App 提供向後兼容性		支援 Kotlin 語言		支援多 DEX 檔案		Android 測試框架，提供單元測試和 UI測試

 

2.Architecture

提供建立穩固，可測試，可維護性高的 App

Data Binding		Lifecycles		LiveData		Navigation		Paging
將可觀察資料綁定到 UI 元件		管理 Activity 和 Fragment 生命週期		當資料改變時通知視圖(View)		處理 App 導航功能		循序的從數據來源讀取資料
Room		ViewModel		WorkManager
流暢存取SQLite		以生命週期方式管理 UI 相關資料		管理後台任務

 

3.Behavior

讓 App 可和標準 Android 服務集成，如 Notification，Permission，Sharing，Assistant

DownloadManager		Media & playback		Notifications		Permissions		Sharing		Slices
排程和管理大量下載		播放媒體(包含Google Cast)		提供通知功能並可向後兼容		檢查和要求 App 權限		用於 Action bar 的共享操作		可在 App 之外顯示資料的 UI

 

4. UI

提供 widgets 讓 App 使用起來不僅簡單且有趣

Animation & transitions		Auto		Emoji		Fragment		Layout
用來移動或轉換widget		幫助開發Android Auto 元件		可在舊版本上使用最新的Emoji功能		可元件化的基本單位		關於App版面配置
Palette		TV		Wear OS By Google
從調色板中提取有用訊息		幫助開發Android TV 元件		幫助開發Android Wear 元件

 

 

 

---

Orignal From: Android Jetpack (噴射背包!!!) 簡介

Read more »

ViewModel 基本紀錄(Android Architecture Component)

Overview

ViewModel 為 Android Architecture Component 其中一部分，主要的用途為以生命週期方式來儲存與管理UI相關數據。好處為當配置更改(螢幕旋轉)之後能夠予許數據繼續存在。

以架構來說通常是作為 MVVM 的 VM(ViewModel) 角色來呈現， 透過把和 View 不相關的邏輯提取出來放到 VM，一方面可以減輕 View 的職責，一方面提高其它模組內聚力，也讓測試更容易撰寫。

Dependency

參考官網

實作 ViewModel

實作方式非常簡單，只要繼承 ViewModel 即可。通常 ViewModel 會和 LiveData 同時使用，關於 LiveDate 請參考這裡
如同 Overview 提到的 ViewModel 可以在配置改變時自動保留數據，因此應該盡量把數據部分放到 ViewModel 而不是 Actvity 或 Fragment。

public class MyViewModel extends ViewModel {  
    
    private static final String TAG = MyViewModel.class.getSimpleName();  
    
  }  
  

Note:通常會和 LiveData一起使用，但這裡為了方便說明，先不加入LiveData。

Using in Activity

public class ViewModelMainActivity extends AppCompatActivity {  
    
    private static final String TAG = ViewModelMainActivity.class.getSimpleName();  
    
    private MyViewModel mViewModel;  
    
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
      super.onCreate(savedInstanceState);  
      setContentView(R.layout.view_model_main_activity);  
    
      mViewModel = ViewModelProviders.of(this).get(MyViewModel.class);  
      Log.d(TAG,"mViewModel.toString():"+ mViewModel.toString());  
    }  
  }

第12行透過 ViewModelProviders.of(this).get(MyViewModel.class); 初始化 mViewModel。
第13行用來測試旋轉螢幕後是否為同一個 ViewModel 實體。接著你可以開始旋轉螢幕了。
Note :
1.注意在 ViewModel 內絕不可引用 View, Lifecycle, 或是任何本身還會引用 activity context 的類別。若 ViewModel 內需要使用 context 就繼承 AndroidViewModel。
2.當呼叫 ViewModelProviders.of(this).get(MyViewModel.class); 之後，ViewModel 就會保存在記憶體中，直到它的作用域消失。也就是當ViewModelMainActivity 為 finish 狀態時，ViewModel 即會消失。

LiveDate 和 ViewModel 共用

LiveData 的用途為提供 observer 可以觀察本身所擁有的數據，而 ViewModel 則是提供 View 數據並可自動處理配置變化所引發的事件。
這 2 者共同使用對於 View 來說便可發揮極大的功效。

public class MyViewModel extends ViewModel {  
    
    private static final String TAG = MyViewModel.class.getSimpleName();  
    
    private MutableLiveData<List<User>> mUsers;  
    
    public LiveData<List<User>> getUsers() {  
      if (mUsers == null) {  
        mUsers = new MutableLiveData<>();  
        loadUsers();  
      }  
      return mUsers;  
    }  
    
    private void loadUsers() {  
     ...  
    }  
  }  
  

 

Scope of ViewModel

從圖中可以看到當 Activity 在 onCreate 時，ViewModel 就跟著產生。而當 Activity finish 之後，呼叫完 onDestroy 方法後，ViewModel 就跟著消失。

在 Fragment 之間分享數據

若同一個 Activity 擁有 2 個 fragment , 也可以使用 ViewModel 讓這 2 個 fragment 共享數據。

public class SharedViewModel extends ViewModel {  
      private final MutableLiveData<Item> selected = new MutableLiveData<Item>();  
    
      public void select(Item item) {  
          selected.setValue(item);  
      }  
    
      public LiveData<Item> getSelected() {  
          return selected;  
      }  
  }  
  

public class MasterFragment extends Fragment {  
    
      private SharedViewModel model;  
    
      public void onCreate(Bundle savedInstanceState) {  
          super.onCreate(savedInstanceState);  
          model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);  
          itemSelector.setOnClickListener(item -> {  
              model.select(item);  
          });  
      }  
  }  
  

public class DetailFragment extends Fragment {  
       
   public void onCreate(Bundle savedInstanceState) {  
          super.onCreate(savedInstanceState);  
     
          SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);  
     
          model.getSelected().observe(this, { item ->  
             // Update the UI.  
          });  
      }  
  }

注意這 2 個 fragment 都使用了 getActivity 來取得 ViewModelProvider，因此，這 2 個 fragment 都接受相同的 SharedViewModel 實體。

這個做法有以下優點
1. Activity 不需要做任何事，也不需要了解 Fragment 之間的溝通。
2. Fragment 不需要彼此了解。若其中一個 Fragment 發生問題，另一個 Fragment 繼續正常工作。

 

 

 

 

 

 

 

---

Orignal From: ViewModel 基本紀錄(Android Architecture Component)

Read more »

LiveData 基本紀錄(Android Architecture Component)

LiveData 為 Android Architecture Component 其中之一，主要用途為持有可觀察數據(observable data)，並讓有註冊且為活躍狀態的觀察者自動收到更新。

若了解或實作過Observer Pattern(觀察者模式)會很容易了解，可以把LiveData看作Subject(主題)也就是資料的來源。對Subject有興趣的observers可以訂閱主題，訂閱完成後當主題內的數據發生變化時，observers便會自動收到通知。

基本上 Observer Pattern 是用來取代 polling 的解決方案。關於Observer Pattern 可以參考這篇

回過頭來，首先看看LiveData的OverView(這裡是官網介紹)

首先LiveData是一種擁有可觀察數據的類別(看字面不好懂，直接看實作吧) e.g.,

  private MutableLiveData<String> mCurrentName = new MutableLiveData<String>();

因為LiveData為abstract class，通常在實作上會以MutableLiveData(LiveData's subclass)取代LiveData。角括號可以傳入任何型別，包含Collections，list等等。

LiveData最大的特色為它具有生命週期感知(Lifecycle-aware)能力，該能力可以讓LiveData得知其他元件(Activity, Fragment, Service)的生命週期。
因此可以避免很多必須手動操作的情況，如螢幕旋轉時需要儲存數據，UI和數據之間的同步，memoey leak等等。

如何使用LiveData

1.建立LiveData實體並持有特定類型的數據。這通常在ViewModel類別內實作

2.建立Observer物件並定義onChanged方法，該方法內容用來描述當LiveData持有的數據改變時所作的事。你通常會在UI Controlller內(Activity, fragment)建立Observer物件

3.使用observe方法連結Observer物件和LiveData物件。observer方法需要傳入LifecycleOwner物件，這讓Observer物件訂閱LiveData物件並讓LiveData可以通知改變。你通常會在UI Controller內(activity, fragment)連結Observer物件

Note:
你可以藉由observeForever(Observer)方法來註冊一個observer而不需要結合LifecycleOwner。

在這種情況下observer會被當作永遠都是活躍的，因此總是會收到改變的資訊。反之，可以使用removeObserver(Observer)來移除observer

當LiveData的資料被更新之後，所有的已註冊且相關連的LifecycleOwner為活躍的observers會收到通知。

Example

1.Create LiveData objects

LiveData可以包含任何類型的數據，如List等等。
LiveData通常儲存在ViewModel內並透過getter方法來存取。

public class NameViewModel extends ViewModel {  
    
    private MutableLiveData<String> mCurrentName = new MutableLiveData<String>();  
    
    public MutableLiveData<String> getCurrentName() {  
      return mCurrentName;  
    }  
  }  
  

Note:確保LiveData儲存在ViewModel而不是activity或fragment

2.Observe LiveData objects

在大多數的情況下，onCreate方法為初始觀察LiveData位置。

在一般的情況下LiveData只在數據有更新時且觀察者為活躍的狀態才發送通知。但有2個例外，第1為當觀察者從非活躍狀態轉為活躍狀態時會收到通知。
第2為當觀察者是第2次從非活躍狀態轉為活躍狀態，則只有在自上次活動狀態以來該值發生變動時才會收到更新。
(也就是說當觀察者第1次從非活躍轉成活躍一定會收到更新。若是第2次從非活躍轉成活躍，且必須儲存的數據發生變化才會收到更新)

public class LiveDataMainActivity extends AppCompatActivity {  
    
    private NameViewModel mViewModel;  
    
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
      super.onCreate(savedInstanceState);  
      setContentView(R.layout.live_data_main_activity);  
    
      mViewModel = ViewModelProviders.of(this).get(NameViewModel.class);  
    
      Observer<String> nameObserver = new Observer<String>() {  
    
        @Override  
        public void onChanged(String newName) {  
          mName.setText(newName);  
        }  
      };  
    
      mViewModel.getCurrentName().observe(this, nameObserver);  
    }  
  }  
  

 

3.Update LiveData objects

LiveData可以透過setValue和postValue方法來改變數據，2者的差別為setValue可用於main Thread，postValue可用於worker thread

String newName = "john doe";  
  mViewModel.getCurrentName().setValue(newName);  
  

因此當setValue呼叫之後，所有已註冊且為活躍的observer便會觸發onChanged方法

 

---

Orignal From: LiveData 基本紀錄(Android Architecture Component)

Read more »

Gson 搭配 Gsonformat 基本使用紀錄

Gson 為 Google製作，可將JSON內容和java object互相轉換的library。

對我來說最大的用途就是可直接將Server回傳的json訊息直接轉換成java object，而不用再一一寫對應的 JsonObject。

而GsonFormat為 android studio 的外掛，用途是當你取得json內容之後，可以幫你產生對應的java object。

兩者搭配起來就可以方便的處理Server回傳訊息。

首先是Gson的部分:
這裡為Gson github連結，相關的安裝和使用都有介紹。

1.Gson Dependency
在 module 的 build.gradle 加入

dependencies {  
  ...  
    implementation 'com.google.code.gson:gson:2.8.5'  
  }

2.Using in code
2-1. Json to java object
首先假設有個User 類別為對應的 java object

public class User {  
    
    private String name;  
    private int age;  
    private String sex;  
    
    public String getName() {  
      return name;  
    }  
    
    public void setName(String name) {  
      this.name = name;  
    }  
    
    public int getAge() {  
      return age;  
    }  
    
    public void setAge(int age) {  
      this.age = age;  
    }  
    
    public String getSex() {  
      return sex;  
    }  
    
    public void setSex(String sex) {  
      this.sex = sex;  
    }  
  }

2-2. java object to json
(就是將已存在的java物件轉成json 格式的string)

  @Test  
    public void test_UserToJSON() {  
      User foxx = new User();  
      foxx.setAge(99);  
      foxx.setName("Foxx");  
      foxx.setSex("male");  
    
      Gson gson = new Gson();  
      String result = gson.toJson(foxx, User.class);  
      System.out.println("userToJSON:" + result);  
      assertEquals("{\"name\":\"Foxx\",\"age\":99,\"sex\":\"male\"}", result);  
    }

第9行即透過 gsong.toJson將 java object轉成 json string

2-3. json to java object

  @Test  
    public void test_JSONToUser() {  
      Gson gson = new Gson();  
      String source = "{\"name\":\"Foxx\",\"age\":99,\"sex\":\"male\"}";  
      User target = gson.fromJson(source, User.class);  
      assertNotNull(target);  
    }

第5行透過gson.fromJson將json string 轉成 java object

 

接著是GsonFormat
1.Install GsonFormat
安裝方式和一般的android studio 外掛相同。
開啟 android studio -> File -> Settings -> Plugins -> Browse repositories
->輸入 gsonformat -> install -> 安裝完成後 重開 android studio

2.How to use
2-1.首先手動建立對應的空class(只有類別名稱無其他內容)，以上面的User為例，我們就先建立一個User的空class。

public class User {  
    
  }  
  

2-2.產生對應json 的內容
假設已取得Server回傳的json string 如下

{  
      "name":"Foxx",  
      "sex":"male",  
      "age":"99"  
  }

回到2-1建立的User class，點擊上方工具欄的Code，再點擊 Generate，選擇GsonFormat，在顯示的視窗中貼上2-2的內容。


點擊OK -> 再點擊OK，完成後User class 如下

public class User {  
    
    private String name;  
    private String sex;  
    private String age;  
    
    public String getName() {  
      return name;  
    }  
    
    public void setName(String name) {  
      this.name = name;  
    }  
    
    public String getSex() {  
      return sex;  
    }  
    
    public void setSex(String sex) {  
      this.sex = sex;  
    }  
    
    public String getAge() {  
      return age;  
    }  
    
    public void setAge(String age) {  
      this.age = age;  
    }  
  }

從第3~29行即是GsonFormat產生的內容。

---

Orignal From: Gson 搭配 Gsonformat 基本使用紀錄

Read more »