Android LiveDataソースコード分析-100日を読み取るソースコード(2)

0.はじめに

ドキュメントの説明によると、LiveDataはJetPackビルドコレクションにも属しています。LiveDataは監視可能なデータホルダークラスです。通常のオブザーバブルとは異なり、LiveDataはライフサイクルを認識します。つまり、アクティビティ、フラグメント、サービスなどの他のアプリケーションコンポーネントのライフサイクルを尊重します。この認識により、LiveDataはアクティブなライフサイクル状態にあるアプリケーションコンポーネントオブザーバーのみを更新します。
利点(以下はグーグルドキュメントから取られ、グーグルはそれを翻訳しました)
(1)UIがデータステータスに準拠していることを確認します
LiveDataはオブザーバーパターンに従います。ライフサイクルの状態が変化すると、LiveDataはObserverオブジェクトに通知します。コードをマージして、これらのObserverオブジェクトのUIを更新できます。アプリケーションデータが変更されるたびに、オブザーバーはUIを更新する代わりに、変更されるたびにUIを更新できます。
(2)メモリリークはありません。
オブザーバーはライフサイクルオブジェクトにバインドされ、関連するライフサイクルが破棄された後にクリーンアップします。非アクティブ
によるクラッシュなし
オブザーバーのライフサイクルが非アクティブの場合(たとえば、バックエンドスタックでのアクティビティの場合)、LiveDataイベントを受信しません。
(3)
UIコンポーネントの手動ライフサイクル処理不要になり、関連データを監視するだけで、監視を停止または再開することはありません。LiveDataは、監視中に関連するライフサイクル状態の変化を認識しているため、これらすべてを自動的に管理します。
(4)常に最新のデータを保持する
ライフサイクルが非アクティブになった場合、再びアクティブになったときに最新のデータを受信します。たとえば、バックグラウンドアクティビティは、フォアグラウンドに戻った直後に最新のデータを受け取ります。
(5)適切な構成変更
構成変更(デバイスのローテーションなど)によりアクティビティまたはセグメントが再作成された場合、利用可能な最新のデータがすぐに受信されます。
(6)リソースの共有
シングルトンパターンを使用してLiveDataオブジェクトを拡張し、システムサービスをラップして、アプリケーションで共有できるようにすることができます。LiveDataオブジェクトはシステムサービスに一度接続されると、リソースを必要とするオブザーバーはLiveDataオブジェクトのみを監視できます。

1.使用する

class MainActivity : AppCompatActivity() {

    val curName: MutableLiveData<String> by lazy {

        MutableLiveData<String>()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        curName.observe(this, Observer<String> {
            println("value is $it")
        })
        curName.value="old value"
    }

}

使用法は非常に簡単です。MutableLiveDataオブジェクトの値が変更されると、MutableLiveDataがLiveDataから継承するObserverのonChangedメソッドが起動されます。

2.目的

(1)LiveDataはライフサイクル認識をどのように実行しますか
(2)イベントを更新する方法
(3)メモリリークを回避する方法

3.分析

3.1LiveDataはライフサイクル認識をどのように実行しますか

LiveDataのオブザーバーメソッドを最初に見てください

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        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().addObserver(wrapper);
    }

最後の行を見てください、owner.getLifecycle()。addObserver(wrapper); ownerは、私たちが使用するアクティビティまたはフラグメントです。これは、
Androidライフサイクルソースコード分析の前の記事ライフサイクルに対応します-100日を読み取るソースコード(1)、ここに追加リスナーはLifecycleBoundObservrであり、このクラスはライフサイクルを検知する方法であるLifecycleObserverを実装します。

3.2イベントを更新する方法

正直なところ、このコントロールはオブザーバーモードであり、イベントのオブザーバーはLifecycleBoundObserverです。このオブジェクトのonStateChangedメソッドを見てください。

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

activieStageChangedメソッドを見てください

void activeStateChanged(boolean newActive) {
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                onInactive();
            }
            if (mActive) {
                dispatchingValue(this);
            }
        }

このメソッドは、メモリリークを防ぐためにライフサイクルを処理するために使用されます。処理のためにデータを監視するために使用される実際のメソッドは、dispatchingValueメソッドです。このメソッドを見てください。

private 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<T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

ObserverWrapperパラメーターがnullでない場合は、considerNotifyメソッドを呼び出します。そうでない場合は、mObserversを反復処理し、considerNotifyを呼び出してから、このメソッドを確認します。

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;
        //noinspection unchecked
        observer.mObserver.onChanged((T) mData);
    }

まず、ObserverWrapperをアクティブ化する必要があるかどうかを判断します。アクティブ化する必要がある場合は、activeStateChangedメソッドを呼び出します。それ以外の場合は、カスタムObserverのonChanged((T)mData)メソッドを呼び出します。

3.3メモリリークを回避する方法

onStateChangedメソッドで呼び出されたactiveStateChanged(shouldBeActive())に戻り、shouldBeActiveメソッドを確認します。

 @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }
        
 public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }        

このメソッドは、現在の状態をSTARTEDと比較します。STARTEDまたはRESUMEDの場合、activeStateChangedで渡されたパラメーターはtrueです。それ以外の場合はfalseです。その後、activeStateChangedメソッドを振り返ります。

void activeStateChanged(boolean newActive) {
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                onInactive();
            }
            if (mActive) {
                dispatchingValue(this);
            }
        }
    }

状態が変化していない場合は直接戻り、そうでない場合はnewActiveに従ってアクティブ状態かどうかを判断します。

          if (wasInactive && mActive) {
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                onInactive();
            }

次に、mActiveおよびactiveCountに従ってonActiveメソッドとonInactiveメソッドを呼び出します。これは一目で明らかです。ライフサイクルがonStartを呼び出すと、アクティブ状態になり、onstopが非アクティブ状態になった後、データが変更されたときにObserverメソッドに移動しないため、メモリリークが回避されます。 。

私の公開アカウントに従ってください

おすすめ

転載: blog.csdn.net/skateboard1/article/details/84330447