ViewMode+LiveData總結

Activity/Fragment只應關注UI，而不應關係操作邏輯，因此操作邏輯應放到Viewmodel中去
下面是我手畫的資料流圖：

首先有Fragment、ViewModel、Livedata這三個物件。

1. Fragment觀察Viewmodel的Livedata資料，如果livedata的值改變會通知Frament。
2. ViewModel獲取資料（網路、資料庫），然後設定Livedata的值
3. Livedata的值改變就通知Fragment
4. Fragment重新整理介面

程式碼如下：
Fragment

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.widget.TextView;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.Observer;

/**
*
* @author hys huyunsong@58.com
* @date 2020/9/19
*/
public class MyActivity extends AppCompatActivity {
   Handler messageHandler;
   MyViewModel myViewModel;
   Handler mainHandler;

   @Override
   protected void onCreate(@Nullable Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       final TextView textView = findViewById(R.id.textView);
       // 新建ViewModel
       myViewModel = new MyViewModel();

       // 子執行緒
       HandlerThread handlerThread = new HandlerThread("");
       handlerThread.start();
       // 子執行緒Handler
       messageHandler = new Handler(handlerThread.getLooper());
       // 主執行緒handler
       mainHandler = new Handler(getMainLooper());
       // 開啟自自執行緒改變資料
       messageHandler.post(new Runnable() {
           @Override
           public void run() {
               int i = 0;
               while (i < 100) {
                   mainHandler.post(new Runnable() {
                       @Override
                       public void run() {
                           myViewModel.requestChangeText();
                       }
                   });
                   try {
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   i++;
               }
           }
       });

       myViewModel.getmText().observe(this, new Observer<String>() {
           @Override
           public void onChanged(final String s) {
               runOnUiThread(new Runnable() {
                   @Override
                   public void run() {
                       textView.setText(s);
                   }
               });

           }
       });
   }
}

viewmodel

import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;

import java.util.Observable;
import java.util.Random;

/**
 * Describe:<p></p>
 * 描述：<p></p>
 *
 * @author hys huyunsong@58.com
 * @date 2020/9/19
 */
public class MyViewModel extends ViewModel implements IMyModelHelper {


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

    public MyViewModel() {
    }

    public MutableLiveData<String> getmText() {
        return mText;
    }

    @Override
    public void requestChangeText() {
        changeText();
    }

    private void changeText(){
        getmText().setValue(new Random(10).toString());
    }
}

package com.loyal888.tets;

/**
 * Describe:<p></p>
 * 描述：<p></p>
 *
 * @author hys huyunsong@58.com
 * @date 2020/9/19
 */
public interface IMyModelHelper  {
    void requestChangeText();
}

總結：資料通知可以使用Observer，實現進一步解耦合

MVP 和MVVM的區別

獲取VidewModel範例

// 新建ViewModel
myViewModel = ViewModelProviders.of(this).get(MyViewModel.class);

VideoModel的生命週期

系統首次呼叫 Activity 物件的 onCreate() 方法時請求 ViewModel。系統可能會在 Activity 的整個生命週期內多次呼叫 onCreate()，如在旋轉裝置螢幕時。ViewModel 存在的時間範圍是從您首次請求 ViewModel 直到 Activity 完成並銷燬。

在當前生命週期為Destrory的時候，清除了mViewModelStore

ViewModel中使用Context

擴充套件AndroidViewModel

ViewModel 物件可以包含 LifecycleObservers，如 LiveData 物件。但是，ViewModel 物件絕不能觀察對生命週期感知型可觀察物件（如 LiveData 物件）的更改。 如果 ViewModel 需要 Application 上下文（例如，為了查詢系統服務），它可以擴充套件 AndroidViewModel 類並設定用於接收 Application 的建構函式，因為 Application 類會擴充套件 Context。

ViewModel原始碼分析

1. ViewModelProvider.of(this)

• 檢查應用的上下文
• 構造了AndroidViewModelFactory
• 返回provider

   public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        return of(activity, null);
    }
    
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity,
            @Nullable Factory factory) {
        // 1. 檢查應用的上下文且必須是application
        Application application = checkApplication(activity);
        if (factory == null) {
        // 2.構造了AndroidViewModelFactory
            factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
        }
        // 3.返回provider
        // 3.1 注意這裡的activity.getViewModelStore()
        return new ViewModelProvider(activity.getViewModelStore(), factory);
    }

2. activity.getViewModelStore()

public ViewModelStore getViewModelStore() {
        if (getApplication() == null) {
            throw new IllegalStateException("Your activity is not yet attached to the "
                    + "Application instance. You can't request ViewModel before onCreate call.");
        }
        if (mViewModelStore == null) {
           	// 獲取上一次設定改變儲存的NonConfigurationInstances，比如螢幕旋轉
            NonConfigurationInstances nc =
                    (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                // Restore the ViewModelStore from NonConfigurationInstances
                // 設定改變，viewModelStore不空，直接使用
                // 這個viewModelStore是在哪裡儲存的？見下文
                mViewModelStore = nc.viewModelStore;
            }
            if (mViewModelStore == null) {
                // 第一次來就新建一個ViewModelStore,儲存的上一次的狀態
                // 新建來之後儲存到哪裡？見下文
                mViewModelStore = new ViewModelStore();
            }
        }
        return mViewModelStore;
    }

3.儲存ViewModelStore

getLastNonConfigurationInstance();
儲存呢？ 呼叫的是ConponentActivity中的onRetainNonConfigurationInstance,呼叫時機介於onStop和onDestroy中間，onSaveInstance之後。

public final Object onRetainNonConfigurationInstance() {
       Object custom = onRetainCustomNonConfigurationInstance();
   	// 這裡就是上文的new出來的mViewModelStore
       ViewModelStore viewModelStore = mViewModelStore;
       if (viewModelStore == null) {
           // No one called getViewModelStore(), so see if there was an existing
           // ViewModelStore from our last NonConfigurationInstance
           NonConfigurationInstances nc =
                   (NonConfigurationInstances) getLastNonConfigurationInstance();
           if (nc != null) {
               viewModelStore = nc.viewModelStore;
           }
       }

       if (viewModelStore == null && custom == null) {
           return null;
       }

       NonConfigurationInstances nci = new NonConfigurationInstances();
       nci.custom = custom;
       // 把mViewModelStore儲存到NonConfigurationInstances中去
       nci.viewModelStore = viewModelStore;
       return nci;
   }

4. 獲取上一次儲存的viewmodel

public ViewModelStore getViewModelStore() {
       if (getApplication() == null) {
           throw new IllegalStateException("Your activity is not yet attached to the "
                   + "Application instance. You can't request ViewModel before onCreate call.");
       }
       if (mViewModelStore == null) {
           NonConfigurationInstances nc =
                   (NonConfigurationInstances) getLastNonConfigurationInstance();
           if (nc != null) {
           
               // Restore the ViewModelStore from NonConfigurationInstances
               //  注意上面這句英文
               mViewModelStore = nc.viewModelStore;
           }
           if (mViewModelStore == null) {
               mViewModelStore = new ViewModelStore();
           }
       }
       return mViewModelStore;
   }

5. 獲取ViewModel
ViewModelProviders.of(this).get(MyViewModel.class);

public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
      String canonicalName = modelClass.getCanonicalName();
      if (canonicalName == null) {
          throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
      }
      return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
  }
  
  public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
  // 上文提到構建出來的mViewModelStore,從HashMap取出範例
      ViewModel viewModel = mViewModelStore.get(key);

      if (modelClass.isInstance(viewModel)) {
          //noinspection unchecked
          // 	有就返回
          return (T) viewModel;
      } else {
          //noinspection StatementWithEmptyBody
          if (viewModel != null) {
              // TODO: log a warning.
          }
      }
      if (mFactory instanceof KeyedFactory) {
          viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
      } else {
      	// 沒有反射建立出來
          viewModel = (mFactory).create(modelClass);
      }
      // 將mViewModelStore儲存到HashMap，儲存的時候會銷燬舊物件
      mViewModelStore.put(key, viewModel);
      //noinspection unchecked
      return (T) viewModel;
  }

public class ViewModelStore {

   private final HashMap<String, ViewModel> mMap = new HashMap<>();

   final void put(String key, ViewModel viewModel) {
       ViewModel oldViewModel = mMap.put(key, viewModel);
       if (oldViewModel != null) {
       	// 舊viewmodel會被清除！！！
           oldViewModel.onCleared();
       }
   }

   final ViewModel get(String key) {
       return mMap.get(key);
   }

   Set<String> keys() {
       return new HashSet<>(mMap.keySet());
   }

   /**
    *  Clears internal storage and notifies ViewModels that they are no longer used.
    */
   public final void clear() {
       for (ViewModel vm : mMap.values()) {
           vm.clear();
       }
       mMap.clear();
   }
}

總結： VieModelStore存在於FragmentActivity中，在設定更改導致Activity銷燬前通過onRetainNonConfiguraionInstance將資料物件儲存，並在重建時通過getLastNonConfigurationInstance將資料還原回來，從而保證了Activity內ViewModelStore 的唯一性和一致性。

LiveData

LiveData 是一種可觀察的資料記憶體類。與常規的可觀察類不同，LiveData 具有生命週期感知能力，意指它遵循其他應用元件（如 Activity、Fragment 或 Service）的生命週期。這種感知能力可確保 LiveData 僅更新處於活躍生命週期狀態的應用元件觀察者。

原始碼分析

構造方法

 public LiveData(T value) {
 		// 儲存具體的值
        mData = value;
        // 當前版本
        mVersion = START_VERSION + 1;
    }
}

觀察Livedata

 myViewModel.getmText().observe(this, new Observer<String>() {
            @Override
            public void onChanged(final String s) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        textView.setText(s);
                    }
                });

            }
        });

observe了什麼

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
       // mObservers 新增了當前觀察者
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

資料改變setValue之後

 protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

   void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                        // 通知並回撥每一個觀察者的回撥方法
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }  

Transformations#map()

eg：

public static <X, Y> LiveData<Y> map(
            @NonNull LiveData<X> source,
            @NonNull final Function<X, Y> mapFunction) {
        final MediatorLiveData<Y> result = new MediatorLiveData<>();
        // X改變了，Y繼續
        result.addSource(source, new Observer<X>() {
            @Override
            public void onChanged(@Nullable X x) {
                result.setValue(mapFunction.apply(x));
            }
        });
        return result;
    }

Transtormations#switchMap

 MutableLiveData userIdLiveData = ...;
 LiveData userLiveData = Transformations.switchMap(userIdLiveData, id ->
     repository.getUserById(id));

 void setUserId(String userId) {
      this.userIdLiveData.setValue(userId);
 }

總結，使用ViewModel和LiveData的優勢

1 不需要手動處理生命週期
ViewModel和LiveData本身是生命週期可感知的

2 確保View可以及時拿到資料狀態

LiveData遵循觀察者模式，資料更改時，LiveData會通知物件。這也是它的優勢，如果UI改變很多，MVP就需要寫很多的介面。View被動的接受Presenter的指令。

3 減少記憶體漏失

LiveData繫結了Lifecycle物件，ViewModel 在生命週期方法中自行清理回收

4 共用資源
單例使用ViewModel和LiveData，可以在程式中共用他們，例兩個fragment共用一個ViewModel

1、建議新增LiveData和ViewModel的詳細使用介紹，方便大家知道一些高階使用方式。比如LiveData對資料的拼裝等。

2、檔案不太能體現出和MVP的對比及優勢。比如ViewModel和View解耦之類的。