【Android Jetpack高手日志】LiveData 从入门到精通

// LiveData & ViewModel 因为这两者通常都一起使用
implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0"
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0"

class NameViewModel : ViewModel() {

    // Create a LiveData with a String
    val currentName: MutableLiveData by lazy {
        MutableLiveData()
    }

    // Rest of the ViewModel...
}

class NameActivity : AppCompatActivity() {

    // Use the 'by viewModels()' Kotlin property delegate
    // from the activity-ktx artifact
    private val model: NameViewModel by viewModels()

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

        // Other code to setup the activity...

        // Create the observer which updates the UI.
        val nameObserver = Observer { newName ->
            // Update the UI, in this case, a TextView.
            nameTextView.text = newName
        }

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
      	//观察数据
        model.currentName.observe(this, nameObserver)
    }
}

button.setOnClickListener {
    val anotherName = "John Doe"
    model.currentName.setValue(anotherName)
}

class StockLiveData(symbol: String) : LiveData() {
    private val stockManager = StockManager(symbol)

    private val listener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        stockManager.requestPriceUpdates(listener)
    }

    override fun onInactive() {
        stockManager.removeUpdates(listener)
    }
}

public class MyFragment : Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val myPriceListener: LiveData = ...
        myPriceListener.observe(viewLifecycleOwner, Observer { price: BigDecimal? ->
            // Update the UI.
        })
    }
}

val userLiveData: LiveData = UserLiveData()
val userName: LiveData = Transformations.map(userLiveData) {
    user -> "${user.name} ${user.lastName}"
}

//两个liveData，由liveDataSwitch决定 返回哪个livaData数据
        MutableLiveData liveData3 = new MutableLiveData();
        MutableLiveData liveData4 = new MutableLiveData();

	//切换条件LiveData，liveDataSwitch的value 是切换条件
        MutableLiveData liveDataSwitch = new MutableLiveData();

	//liveDataSwitchMap由switchMap()方法生成，用于添加观察者
        LiveData liveDataSwitchMap = Transformations.switchMap(liveDataSwitch, new Function>() {
            @Override
            public LiveData apply(Boolean input) {
            //这里是具体切换逻辑：根据liveDataSwitch的value返回哪个liveData
                if (input) {
                    return liveData3;
                }
                return liveData4;
            }
        });

        liveDataSwitchMap.observe(this, new Observer() {
            @Override
            public void onChanged(String s) {
                Log.i(TAG, "onChanged2: " + s);
            }
        });

        boolean switchValue = true;
        liveDataSwitch.setValue(switchValue);//设置切换条件值

        liveData3.setValue("liveData3");
        liveData4.setValue("liveData4");

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

@SuppressWarnings("WeakerAccess") /* synthetic access */
    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

private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }
        // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
        //
        // we still first check observer.active to keep it as the entrance for events. So even if
        // the observer moved to an active state, if we've not received that event, we better not
        // notify for a more predictable notification order.
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        observer.mObserver.onChanged((T) mData);
    }

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer super T> observer) {
        assertMainThread("observe");
        //如果 LifecycleOwner 的 DESTROYED，return
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
      	//包装类
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        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()`的真正实现是 Activity 中的 `LifecycleRegistry`（如果在Activity 中调用的话）。
        owner.getLifecycle().addObserver(wrapper); 
    }

protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); //发送到主线程
    }

private final Runnable mPostValueRunnable = new Runnable() {
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            setValue((T) newValue);  //最终还是调用了 setValue方法
        }
    };

class LiveDataBus {
    internal val liveDatas by lazy { mutableMapOf>() }

    @Synchronized
    private fun bus(channel: String): LiveData{
        return liveDatas.getOrPut(channel){
            LiveDataEvent(channel)
        } as LiveData
    }

    fun  with(channel: String): LiveData{
        return bus(channel)
    }

    companion object{
        private val INSTANCE by lazy { LiveDataBus() }
        @JvmStatic
        fun get() = INSTANCE
    }
}

//ViewModel.java
private val _cartCountLD: MutableLiveData = MutableLiveData()
val cartCountLD: LiveData
    get() = _cartCountLD

private val _saveBirthdayLD: MutableLiveData = MutableLiveData()
val saveBirthdayLD: LiveData
		get() = _saveBirthdayLD

class MainActivity : AppCompatActivity() {
    private var jetpackLiveData: MutableLiveData = MutableLiveData()
    private val TAG = "================"
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        jetpackLiveData.observe(this,Observer {
            Log.i(TAG, "observe value:"+it+" state:"+this.lifecycle.currentState)
        })
      	Log.i(TAG, "onCreate: "+" state:"+this.lifecycle.currentState)
        jetpackLiveData.value = "onCreate"
    }

    override fun onStart() {
        super.onStart()
        Log.i(TAG, "onStart: "+" state:"+this.lifecycle.currentState)
        jetpackLiveData.value = "onStart"
    }

    override fun onResume() {
        super.onResume()
        Log.i(TAG, "onResume: "+" state:"+this.lifecycle.currentState)
        jetpackLiveData.value = "onResume"
    }

    override fun onPause() {
        super.onPause()
        Log.i(TAG, "onPause: "+" state:"+this.lifecycle.currentState)
        jetpackLiveData.value = "onPause"
    }

    override fun onStop() {
        super.onStop()
        Log.i(TAG, "onStop: "+" state:"+this.lifecycle.currentState)
        jetpackLiveData.value = "onStop"
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.i(TAG, "onDestroy: "+" state:"+this.lifecycle.currentState)
        jetpackLiveData.value = "onDestroy"
    }
}

jetpackdemo I/================: onCreate:  state:INITIALIZED
jetpackdemo I/================: onStart:  state:CREATED
jetpackdemo I/================: observe value:onStart state:STARTED //STARTED 状态
jetpackdemo I/================: onResume:  state:STARTED
jetpackdemo I/================: observe value:onResume state:STARTED //STARTED 状态
jetpackdemo I/================: onPause:  state:STARTED
jetpackdemo I/================: observe value:onPause state:STARTED //STARTED 状态
jetpackdemo I/================: onStop:  state:CREATED
jetpackdemo I/================: onDestroy:  state:DESTROYED

override fun onResume() {
        super.onResume()
        Log.i(TAG, "onResume: "+" state:"+this.lifecycle.currentState)
        jetpackLiveData.value = "onResume"

        Handler().postDelayed(Runnable {
            Log.i(TAG, "onResume: ==========500 毫秒之后===="+this.lifecycle.currentState)
        },500)
    }

jetpackdemo I/================: onResume: ==========500 毫秒之后====RESUMED