【移動應(yīng)用開發(fā)技術(shù)】Android中Lifecycle的作用是什么

【移動應(yīng)用開發(fā)技術(shù)】Android中Lifecycle的作用是什么

Android中Lifecycle的作用是什么？相信很多沒有經(jīng)驗的人對此束手無策，為此本文總結(jié)了問題出現(xiàn)的原因和解決方法，通過這篇文章希望你能解決這個問題。

Lifecycle的簡單介紹Lifecycle的介紹，我們還是拿Google的官方文檔作為參考吧。Lifecycle主要解決的是業(yè)務(wù)和Activity/Fragment生命周期相關(guān)的問題。例如：我們在onResume()/onStart()中請求定位，在onPause()/onStop()中停止定位。那么我們一般的做法：class

MyLocationListener

{

public

MyLocationListener(Context

context,

Callback

callback)

{

//

...

}

void

start()

{

//

connect

to

system

location

service

}

void

stop()

{

//

disconnect

from

system

location

service

}

}

class

MyActivity

extends

AppCompatActivity

{

private

MyLocationListener

myLocationListener;

@Override

public

void

onCreate(...)

{

myLocationListener

=

new

MyLocationListener(this,

(location)

->

{

//

update

UI

});

}

@Override

public

void

onStart()

{

super.onStart();

myLocationListener.start();

//

manage

other

components

that

need

to

respond

//

to

the

activity

lifecycle

}

@Override

public

void

onStop()

{

super.onStop();

myLocationListener.stop();

//

manage

other

components

that

need

to

respond

//

to

the

activity

lifecycle

}

}上面的代碼雖然看起來還可以，但在真實的應(yīng)用程序中，可能會有很多的方法都需要根據(jù)當(dāng)前Activity/Fragment的生命周期來進行不同的操作。因此其生命周期方法中可能會被放置大量代碼，例如onStart()和onStop()中，這使得它們難以維護。因此Lifecycle應(yīng)運而生！3.Lifecycle的使用Lifecycle已經(jīng)發(fā)布了release版，所以其中的一些默認支持已經(jīng)包含到了support-v7:26.1.0以及更高。添加依賴：implementation

"android.arch.lifecycle:extensions:1.1.1"

annotationProcessor

"android.arch.lifecycle:compiler:1.1.1"使用方式1：實現(xiàn)LifecycleObserver接口，使用@OnLifecycleEvent注解，通過編譯時注解生成代碼：public

class

MyLifecycleObserver

implements

LifecycleObserver

{

private

static

final

String

TAG

=

MyLifecycleObserver.class.getSimpleName();

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)

public

void

start(LifecycleOwner

lifecycleOwner)

{

Lifecycle.State

currentState

=

lifecycleOwner.getLifecycle().getCurrentState();

Log.d(TAG,

"start:

"

+

currentState);

}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

public

void

stop(LifecycleOwner

lifecycleOwner)

{

Log.d(TAG,

"stop:

"

+

lifecycleOwner.getLifecycle().getCurrentState());

}

}

APT生成的代碼

使用方式2：實現(xiàn)GenericLifecycleObserver接口，實現(xiàn)其onStateChanged方法：public

class

MyLifecycleObserver

implements

GenericLifecycleObserver

{

private

static

final

String

TAG

=

MyLifecycleObserver.class.getSimpleName();

@Override

public

void

onStateChanged(LifecycleOwner

source,

Lifecycle.Event

event)

{

Log.d(TAG,

());

}

}創(chuàng)建完成后，我們需要將其添加：public

class

MainActivity

extends

AppCompatActivity

{

@Override

protected

void

onCreate(Bundle

savedInstanceState)

{

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

getLifecycle().addObserver(new

MyLifecycleObserver());

}

}結(jié)果圖：方法1方法24.源碼分析1.Lifecycle的獲取根據(jù)源碼追蹤我們可以看到Lifecycle是在SupportActivity中：private

LifecycleRegistry

mLifecycleRegistry

=

new

LifecycleRegistry(this);

@Override

public

Lifecycle

getLifecycle()

{

return

mLifecycleRegistry;

}這里還有個挺重要的代碼：SupportActivity.javaprotected

void

onCreate(@Nullable

Bundle

savedInstanceState)

{

super.onCreate(savedInstanceState);

ReportFragment.injectIfNeededIn(this);

}ReportFragment.javapublic

static

void

injectIfNeededIn(Activity

activity)

{

android.app.FragmentManager

manager

=

activity.getFragmentManager();

if

(manager.findFragmentByTag(REPORT_FRAGMENT_TAG)

==

null)

{

manager.beginTransaction().add(new

ReportFragment(),

REPORT_FRAGMENT_TAG).commit();

manager.executePendingTransactions();

}

}這里在Activity中添加了一個Fragment，至于作用，留到后面在講。2.addObserveraddObserver方法的話，還是簡單來看吧：LifecycleRegistry.java@Override

public

void

addObserver(@NonNull

LifecycleObserver

observer)

{

State

initialState

=

mState

==

DESTROYED

?

DESTROYED

:

INITIALIZED;

ObserverWithState

statefulObserver

=

new

ObserverWithState(observer,

initialState);

ObserverWithState

previous

=

mObserverMap.putIfAbsent(observer,

statefulObserver);

//

對狀態(tài)的修正，這里會對已經(jīng)過去的狀態(tài)進行分發(fā)。也就是說如果添加observer時狀態(tài)已經(jīng)改變，那么也會被通知到！

}

//

有狀態(tài)的Observer

static

class

ObserverWithState

{

State

mState;

GenericLifecycleObserver

mLifecycleObserver;

ObserverWithState(LifecycleObserver

observer,

State

initialState)

{

mLifecycleObserver

=

Lifecycling.getCallback(observer);

mState

=

initialState;

}

void

dispatchEvent(LifecycleOwner

owner,

Event

event)

{

State

newState

=

getStateAfter(event);

mState

=

min(mState,

newState);

mLifecycleObserver.onStateChanged(owner,

event);

mState

=

newState;

}

}我們將實現(xiàn)的接口通過裝飾者（我認為是這樣）模式轉(zhuǎn)成ObserverWithState對象，并將該對象添加到mObserverMap中。

在ObserverWithState的構(gòu)造方法中，有對我們傳入的LifecycleObserver進行包裝：Lifecycling.java@NonNull

static

GenericLifecycleObserver

getCallback(Object

object)

{

//

這里應(yīng)該算第三種實現(xiàn)方式，然而FullLifecycleObserver不是public，所以不能使用

if

(object

instanceof

FullLifecycleObserver)

{

return

new

FullLifecycleObserverAdapter((FullLifecycleObserver)

object);

}

//

我們的第一種方式

if

(object

instanceof

GenericLifecycleObserver)

{

return

(GenericLifecycleObserver)

object;

}

//

通過注解生成的

final

Class<?>

klass

=

object.getClass();

//

將生成的MyLifecycleObserver_LifecycleAdapter放到Map中

int

type

=

getObserverConstructorType(klass);

if

(type

==

GENERATED_CALLBACK)

{

List<Constructor<?

extends

GeneratedAdapter>>

constructors

=

sClassToAdapters.get(klass);

if

(constructors.size()

==

1)

{

GeneratedAdapter

generatedAdapter

=

createGeneratedAdapter(

constructors.get(0),

object);

return

new

SingleGeneratedAdapterObserver(generatedAdapter);

}

GeneratedAdapter[]

adapters

=

new

GeneratedAdapter[constructors.size()];

for

(int

i

=

0;

i

<

constructors.size();

i++)

{

adapters[i]

=

createGeneratedAdapter(constructors.get(i),

object);

}

return

new

CompositeGeneratedAdaptersObserver(adapters);

}

return

new

ReflectiveGenericLifecycleObserver(object);

}根據(jù)我們傳入的對象進行解析，最終返回結(jié)果為：GenericLifecycleObserver或者GenericLifecycleObserver的實現(xiàn)類。附獲取生成MyLifecycleObserver_LifecycleAdapter代碼：//

通過名稱獲取

public

static

String

getAdapterName(String

className)

{

return

className.replace(".",

"_")

+

"_LifecycleAdapter";

}最終通過Class.forName方式獲得Class。3.事件分發(fā)Lifecycle的事件分發(fā)在ObserverWithState類中：//

事件分發(fā)

void

dispatchEvent(LifecycleOwner

owner,

Event

event)

{

State

newState

=

getStateAfter(event);

mState

=

min(mState,

newState);

mLifecycleObserver.onStateChanged(owner,

event);

mState

=

newState;

}看下哪里調(diào)用了dispatchEvent方法：

調(diào)用

我們看這個方法，其中一個在addObserver中調(diào)用，另外的兩個都會通過sync()方法調(diào)用：//

happens

only

on

the

top

of

stack

(never

in

reentrance),

//

so

it

doesn't

have

to

take

in

account

parents

private

void

sync()

{

LifecycleOwner

lifecycleOwner

=

mLifecycleOwner.get();

if

(lifecycleOwner

==

null)

{

Log.w(LOG_TAG,

"LifecycleOwner

is

garbage

collected,

you

shouldn't

try

dispatch

"

+

"new

events

from

it.");

return;

}

//

最新的狀態(tài)和當(dāng)前狀態(tài)不一致，則需要進行狀態(tài)修改

while

(!isSynced())

{

mNewEventOccurred

=

false;

//

no

need

to

check

eldest

for

nullability,

because

isSynced

does

it

for

us.

if

(mSpareTo(mObserverMap.eldest().getValue().mState)

<

0)

{

backwardPass(lifecycleOwner);

}

Entry<LifecycleObserver,

ObserverWithState>

newest

=

mObserverMap.newest();

if

(!mNewEventOccurred

&&

newest

!=

null

&&

mSpareTo(newest.getValue().mState)

>

0)

{

forwardPass(lifecycleOwner);

}

}

mNewEventOccurred

=

false;

}

//

是否狀態(tài)同步的

private

boolean

isSynced()

{

if

(mObserverMap.size()

==

0)

{

return

true;

}

//

最新的和最后添加的Observer狀態(tài)一致，并且當(dāng)前的狀態(tài)和最新狀態(tài)一致，則已經(jīng)同步了

State

eldestObserverState

=

mObserverMap.eldest().getValue().mState;

State

newestObserverState

=

mObserverMap.newest().getValue().mState;

return

eldestObserverState

==

newestObserverState

&&

mState

==

newestObserverState;

}這里的同步方法用于同步當(dāng)前Observer的狀態(tài)，如果最新的和最老的Observer的狀態(tài)不一致或者當(dāng)前的狀態(tài)和最新的狀態(tài)不一致時，那么需要進行狀態(tài)同步。同步包括了向前同步和向后同步。調(diào)用sync()方法一共就兩處，一處在addObserver方法，另一處是moveToState方法，而調(diào)用moveToState方法也有兩處：@SuppressWarnings("WeakerAccess")

@MainThread

public

void

markState(@NonNull

State

state)

{

moveToState(state);

}

public

void

handleLifecycleEvent(@NonNull

Lifecycle.Event

event)

{

State

next

=

getStateAfter(event);

moveToState(next);

}handleLifecycleEvent方法有很多處調(diào)用：handleLifecycleEvent調(diào)用

看圖的話，就可以知道Fragment在不同的生命周期調(diào)用了handleLifecycleEvent方法，隨便看一個吧：

ON_CREATE還記得上面說的ReportFragment嗎？這里也出現(xiàn)了，我們看下ReportFragment到底做什么的：//

調(diào)用Activity的

private

voi