Lifecycle Activity生命周期感知组件

其他 2018-09-09 19:55:58 阅读次数: 0

官方文档


生命周期感知组件[Lifecycle-aware components]执行操作[perform actions]以响应另一个组件(例如活动和片段)的生命周期状态的更改。 这些组件可帮助您生成更易于组织[better-organized]且通常更轻量级[lighter-weight]的代码，并且这些代码更易于维护。

一种常见的模式是，在活动和片段的生命周期方法中实现依赖组件的操作[to implement the actions of the dependent components in the lifecycle methods of activities and fragments]。 但是，这种模式导致代码组织不良[poor organization]以及错误的增加[to the proliferation of errors]。 通过使用生命周期感知组件，您可以将依赖组件的代码移出生命周期方法、并移入组件本身。

android.arch.lifecycle 包提供了类和接口，使您可以构建生命周期感知组件，这些组件可以根据活动或片段的当前生命周期状态自动调整其行为[automatically adjust their behavior]。

Android框架中定义的大多数应用程序组件都附加了生命周期。生命周期由操作系统或流程中运行的框架代码所管理。它们是Android工作原理的核心，您的应用程序必须尊重它们。 不这样做可能会触发内存泄漏甚至应用程序崩溃。

想象一下，我们有一个活动，在屏幕上显示设备位置。 常见的实现可能如下所示： 
class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {...}
    void start() {...}  // connect to system location service
    void stop() {...} // disconnect from system location service
}
5
5
 
1 
class MyLocationListener {
2 
    public MyLocationListener(Context context, Callback callback) {...}
3 
    void start() {...}  // connect to system location service
4 
    void stop() {...} // disconnect from system location service
5 
}
class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        ...
        myLocationListener = new MyLocationListener(this, (location) -> {...});
    }

    @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
    }
}
21
21
 
1 
class MyActivity extends AppCompatActivity {
2 
    private MyLocationListener myLocationListener;
3
4 
    @Override
5 
    public void onCreate(...) {
6 
        ...
7 
        myLocationListener = new MyLocationListener(this, (location) -> {...});
8 
    }
9
10 
    @Override
11 
    public void onStart() {
12 
        super.onStart();
13 
        myLocationListener.start(); // manage other components that need to respond to the activity lifecycle
14 
    }
15
16 
    @Override
17 
    public void onStop() {
18 
        super.onStop();
19 
        myLocationListener.stop(); // manage other components that need to respond to the activity lifecycle
20 
    }
21 
}

即使这个示例看起来很好，但在真实的应用程序中，最终会有太多的调用来管理UI和其他组件以响应生命周期的当前状态[you end up having too many calls that manage the UI and other components in response to the current state of the lifecycle]。管理多个组件会在生命周期方法中放置大量代码，例如onStart()和onStop()，这使得它们难以维护。

此外[Moreover]，无法保证[guarantee]组件在活动或片段停止之前启动。如果我们需要执行长时间运行的操作，尤其是 onStart() 中的某些配置检查，则尤其如此。 这可能会导致 onStop() 方法在 onStart() 之前完成的竞争条件[race condition]，从而使组件保持活动的时间超过了其所需的时间[keeping the component alive longer than it's needed]。 
@Override
public void onStart() {
	super.onStart();
	Util.checkUserStatus(result -> { //配置检查
	    if (result) {
		    myLocationListener.start(); // what if this callback is invoked AFTER activity is stopped?
	    }
	});
}

@Override
public void onStop() {
	super.onStop();
	myLocationListener.stop();
}
15
15
 
1 
@Override
2 
public void onStart() {
3 
    super.onStart();
4 
    Util.checkUserStatus(result -> { //配置检查
5 
        if (result) {
6 
            myLocationListener.start(); // what if this callback is invoked AFTER activity is stopped?
7 
        }
8 
    });
9 
}
10
11 
@Override
12 
public void onStop() {
13 
    super.onStop();
14 
    myLocationListener.stop();
15 
}
android.arch.lifecycle 包提供了类和接口，可帮助您以弹性和隔离的方式[resilient and isolated way]解决这些问题。

Lifecycle

package android.arch.lifecycle;
public abstract class Lifecycle
2
2
 
1 
package android.arch.lifecycle;
2 
public abstract class Lifecycle
Lifecycle 是一个类，它包含有关组件 (如活动或片段)生命周期状态的信息，并允许其他对象观察此状态。
Lifecycle 使用两个主要枚举来跟踪其关联组件的生命周期状态：
  • Event：由框架和Lifecycle类所调度的生命周期事件。这些事件映射到活动和片段中的回调事件。
  • State：由Lifecycle对象所跟踪[tracked]的组件的当前状态。
    
将状态视为图形的节点[nodes]，将事件视为这些节点之间的边缘[edges]。 
public boolean isAtLeast(@NonNull State state) {
	return compareTo(state) >= 0; //return true if this State is greater or equal to the given state
}
3
3
 
1 
public boolean isAtLeast(@NonNull State state) {
2 
    return compareTo(state) >= 0; //return true if this State is greater or equal to the given state
3 
}

类可以通过向其方法添加注解来监视组件的生命周期状态。然后，您可以通过调用 Lifecycle 类的 addObserver() 方法并传递观察者的实例来添加观察者： 
myLifecycleOwner.getLifecycle().addObserver(new MyObserver());
1
1
 
1 
myLifecycleOwner.getLifecycle().addObserver(new MyObserver());


LifecycleOwner 和 LifecycleObserver

LifecycleOwner 是一个单一方法的接口，表示该类具有生命周期。 此接口从各个[ individual ]类(如Fragment和AppCompatActivity)中抽象出生命周期的所有权[ ownership ]，并允许编写与其一起使用的组件。 任何自定义应用程序类都可以实现 LifecycleOwner 接口 。 
/**
 * A class that has an Android lifecycle. These events can be used by custom components to
 * handle lifecycle changes without implementing any code inside the Activity or the Fragment.
 */
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle(); //Returns the Lifecycle of the provider.
}
9
9
 
1 
/**
2 
 * A class that has an Android lifecycle. These events can be used by custom components to
3 
 * handle lifecycle changes without implementing any code inside the Activity or the Fragment.
4 
 */
5 
@SuppressWarnings({"WeakerAccess", "unused"})
6 
public interface LifecycleOwner {
7 
    @NonNull
8 
    Lifecycle getLifecycle(); //Returns the Lifecycle of the provider.
9 
}

LifecycleObserver 接口是一个标记接口，它没有任何方法，而是依赖于 OnLifecycleEvent 带注解的方法。实现 LifecycleObserver 的组件与实现 LifecycleOwner 的组件无缝协作[work seamlessly]，因为 Owner 可以提供生命周期，Observer 可以注册观察。 
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver { }
2
2
 
1 
@SuppressWarnings("WeakerAccess")
2 
public interface LifecycleObserver { }

对于位置跟踪示例，我们可以使 MyLocationListener 类实现 LifecycleObserver，然后在 onCreate() 方法中 使用 activity 的 Lifecycle 初始化它。这允许 MyLocationListener 类自给自足[self-sufficient]，这意味着响应生命周期状态变化的逻辑在 MyLocationListener 而不是 activity 中声明。通过让各个组件存储自己的逻辑，使得活动和片段的逻辑更易于管理。 
myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {...});
1
1
 
1 
myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {...});

一个常见的用例是，如果 Lifecycle 现在不处于良好状态[a good state]，则应避免调用某些回调。 例如，如果在保存活动状态后执行 回调运行片段事务，则会触发崩溃，因此我们永远不会想要调用这种回调。

为了使这种情况下的使用更简洁[To make this use case easy]，Lifecycle 类允许其他对象查询当前状态。 
if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
    // connect if not connected
}
3
3
 
1 
if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
2 
    // connect if not connected
3 
}
通过此实现，我们的 LocationListener 类完全可以识别生命周期。如果我们需要使用来自另一个活动或片段的 LocationListener，我们只需要初始化它。 所有设置和拆卸操作都由类本身管理。

如果库提供了需要使用Android生命周期的类，我们建议您使用生命周期感知组件。您的库客户端可以轻松地集成这些组件，而无需在客户端进行手动生命周期管理。

Support Library 26.1.0 及更高版本中的片段和活动已实现 LifecycleOwner 接口。

Activity 中的使用案例

Activity 需要为 FragmentActivity 或其子类才能使用： 
getLifecycle().addObserver(new BaseActivityLifecycleObserver());
1 
getLifecycle().addObserver(new BaseActivityLifecycleObserver());
注册后的日志： 
Activity【onCreate】
Observer【onCreate】
Activity【onStart】
Observer【onStart】
Activity【onResume】
Observer【onResume】

Observer【onPause】
Activity【onPause】
Observer【onStop】
Activity【onStop】
Observer【onDestroy】
Activity【onDestroy】
13
13
 
1 
Activity【onCreate】
2 
Observer【onCreate】
3 
Activity【onStart】
4 
Observer【onStart】
5 
Activity【onResume】
6 
Observer【onResume】
7
8 
Observer【onPause】
9 
Activity【onPause】
10 
Observer【onStop】
11 
Activity【onStop】
12 
Observer【onDestroy】
13 
Activity【onDestroy】

监测Activity方式一

public class BaseActivityLifecycleObserver implements GenericLifecycleObserver {
	
	@Override
	public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
		switch (event) {
			case ON_CREATE:
				Log.i("bqt", "Observer【onCreate】");
				break;
			case ON_START:
				Log.i("bqt", "Observer【onStart】");
				break;
			case ON_RESUME:
				Log.i("bqt", "Observer【onResume】");
				break;
			case ON_PAUSE:
				Log.i("bqt", "Observer【onPause】");
				break;
			case ON_STOP:
				Log.i("bqt", "Observer【onStop】");
				break;
			case ON_DESTROY:
				Log.i("bqt", "Observer【onDestroy】");
				break;
			default:
				break;
		}
	}
}
28
28
 
1 
public class BaseActivityLifecycleObserver implements GenericLifecycleObserver {
2
3 
    @Override
4 
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
5 
        switch (event) {
6 
            case ON_CREATE:
7 
                Log.i("bqt", "Observer【onCreate】");
8 
                break;
9 
            case ON_START:
10 
                Log.i("bqt", "Observer【onStart】");
11 
                break;
12 
            case ON_RESUME:
13 
                Log.i("bqt", "Observer【onResume】");
14 
                break;
15 
            case ON_PAUSE:
16 
                Log.i("bqt", "Observer【onPause】");
17 
                break;
18 
            case ON_STOP:
19 
                Log.i("bqt", "Observer【onStop】");
20 
                break;
21 
            case ON_DESTROY:
22 
                Log.i("bqt", "Observer【onDestroy】");
23 
                break;
24 
            default:
25 
                break;
26 
        }
27 
    }
28 
}

监测Activity方式二

public class BaseActivityLifecycleObserver implements LifecycleObserver {
	@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
	public void onCreate() {
		Log.i("bqt", "Observer【onCreate】");
	}
	
	@OnLifecycleEvent(Lifecycle.Event.ON_START)
	public void onStart() {
		Log.i("bqt", "Observer【onStart】");
	}
	
	@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
	public void onResume() {
		Log.i("bqt", "Observer【onResume】");
	}
	
	@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
	public void onPause() {
		Log.i("bqt", "Observer【onPause】");
	}
	
	@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
	public void onStop() {
		Log.i("bqt", "Observer【onStop】");
	}
	
	@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
	public void onDestroy() {
		Log.i("bqt", "Observer【onDestroy】");
	}
	
	@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
	public void onAnyStateChanged() {
		//Log.i("bqt", "【onAnyStateChanged】");
	}
}
36
36
 
1 
public class BaseActivityLifecycleObserver implements LifecycleObserver {
2 
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
3 
    public void onCreate() {
4 
        Log.i("bqt", "Observer【onCreate】");
5 
    }
6
7 
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
8 
    public void onStart() {
9 
        Log.i("bqt", "Observer【onStart】");
10 
    }
11
12 
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
13 
    public void onResume() {
14 
        Log.i("bqt", "Observer【onResume】");
15 
    }
16
17 
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
18 
    public void onPause() {
19 
        Log.i("bqt", "Observer【onPause】");
20 
    }
21
22 
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
23 
    public void onStop() {
24 
        Log.i("bqt", "Observer【onStop】");
25 
    }
26
27 
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
28 
    public void onDestroy() {
29 
        Log.i("bqt", "Observer【onDestroy】");
30 
    }
31
32 
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
33 
    public void onAnyStateChanged() {
34 
        //Log.i("bqt", "【onAnyStateChanged】");
35 
    }
36 
}

Fragment 中使用案例

使用方式和Activity完全一样： 
public class MainFragment extends Fragment {
	public MainFragment() {
		getLifecycle().addObserver(new BaseActivityLifecycleObserver());
	}
}
x
1 
public class MainFragment extends Fragment {
2 
    public MainFragment() {
3 
        getLifecycle().addObserver(new BaseActivityLifecycleObserver());
4 
    }
5 
}
注册后的日志： 
Fragment【onAttach】
Fragment【onCreate】
    Observer【onCreate】
Fragment【onViewCreated】
Fragment【onActivityCreated】
Fragment【onStart】
    Observer【onStart】
Fragment【onResume】
    Observer【onResume】

    Observer【onPause】
Fragment【onPause】
    Observer【onStop】
Fragment【onStop】
Fragment【onDestroyView】
    Observer【onDestroy】
Fragment【onDestroy】
Fragment【onDetach】
x
 
1 
Fragment【onAttach】
2 
Fragment【onCreate】
3 
    Observer【onCreate】
4 
Fragment【onViewCreated】
5 
Fragment【onActivityCreated】
6 
Fragment【onStart】
7 
    Observer【onStart】
8 
Fragment【onResume】
9 
    Observer【onResume】
10
11 
    Observer【onPause】
12 
Fragment【onPause】
13 
    Observer【onStop】
14 
Fragment【onStop】
15 
Fragment【onDestroyView】
16 
    Observer【onDestroy】
17 
Fragment【onDestroy】
18 
Fragment【onDetach】
2018-9-9

猜你喜欢

转载自www.cnblogs.com/baiqiantao/p/9614683.html
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022