Hement：项目中的LifeCycle（五）

最新推荐文章于 2023-03-15 15:16:14 发布
最新推荐文章于 2023-03-15 15:16:14 发布
阅读量151 收藏
点赞数
文章标签： 移动开发 java 数据库
原文链接：https://juejin.im/post/5c1b73196fb9a04a01644a02
版权

  • GitHub地址：Hement:持续更新中

  • apk下载地址

  • app详情

  • 欢迎关注我的公众号

  • LifeCycle

  • 在17年的谷歌IO大会上，Google官方向我们推出了 Android Architecture Components,其中谈到Android组件处理生命周期的问题，向我们介绍了 Handling Lifecycles。

  • 由于和小组成员讨论过，感觉使用时机还没有到，而且那个时候我反编译微信的apk，发现也没有使用的到，所以这个框架的学习计划就不断地搁浅，前几天又反编译了一下微信的安卓apk，发现它使用了来减少代码的臃肿！ 推荐一个**反编译工具**

  • 所以就有必要了解它到底是个什么东西

  • 为什么要使用Lifecycle

  • 我们在处理Activity或者Fragment组件的生命周期相关时，不可避免会遇到这样的问题： 我们在Activity的onCreate()中初始化某些成员（比如MVP架构中的Presenter，或者AudioManager、MediaPlayer等），然后在onStop中对这些成员进行对应处理，在onDestroy中释放这些资源，这样导致我们的代码也许会像这样：


 class MyPresenter{
    public MyPresenter() {
    }

    void create() {
        //do something
    }

    void destroy() {
        //do something
    }
}

class MyActivity extends AppCompatActivity {
    private MyPresenter presenter;

    public void onCreate(...) {
        presenter= new MyPresenter ();
        presenter.create();
    }

    public void onDestroy() {
        super.onDestroy();
        presenter.destory();
    }
}
复制代码

  • 代码没有问题，关键问题是，实际生产环境中 ，这样的代码会非常复杂，你最终会有太多的类似调用并且会导致 onCreate() 和 onDestroy() 方法变的非常臃肿。

  • 如何使用Lifecycle 在前面我写过一篇文章Hement：MVP架构中的网络框架(RxJava2+Retrofit2+RxAndroid)（二）这是没有使用的Lifecycle的网络请求的Presenter必须在onDestroy时候去销毁view！

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mMainPresenter.detachView();
    }
复制代码
  • 能不能集成到BasePresenter的中去呢？其实是可以滴,只需要把BasePresenter实现LifecycleObserver即可
public class NewBasePresenter<V extends IMvpView> implements LifecycleObserver {


    public static final String TAG = "NewBasePresenter";
    private V mMvpView;


    public void attachView(V mvpView) {
        mMvpView = mvpView;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Timber.tag(TAG).d("onDestroy lifecycle event.start ");
        detachView();
    }

    /**
     * 由于在每次这个方法都会去执行，所以可以这样进行
     * @param owner
     * @param event
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onLifecycleChanged(@NotNull LifecycleOwner owner, @NotNull Lifecycle.Event event) {

    }
    public void detachView() {
        mMvpView = null;
    }
    /**
     * 判断是否还在连接在一起的
     * @return
     */
    public boolean isViewAttached() {
        return mMvpView != null;
    }

    /**
     * 获取View
     * @return
     */
    public V getMvpView() {
        return mMvpView;
    }

    /**
     * 检查View是否附着
     */
    public void checkViewAttached() {
        if (!isViewAttached()) throw new MvpViewNotAttachedException();
    }

    public static class MvpViewNotAttachedException extends RuntimeException {
        public MvpViewNotAttachedException() {
            super("在绑定数据之前一定要绑定视图");
        }
    }

    /**
     * 这是Observer 中的 onServer ,当我们调用这个方法，直接就不会走到 onNext中去
     * @param disposable
     */
    public  void dispose(Disposable disposable) {
        if (disposable != null && !disposable.isDisposed()) {
            disposable.dispose();
        }
    }
}
复制代码
  • 具体的Preseter的实现
public class NewNetWorkPresenter extends NewBasePresenter<NetWorkView> {


    private Disposable mDisposable;
    private final IRemoteServer mIRemoteServer;

    public NewNetWorkPresenter() {
        mIRemoteServer = IRemoteServer.Creator.newHementService();
    }

    @Override
    public void attachView(NetWorkView mvpView) {
        super.attachView(mvpView);
    }

    @Override
    public void detachView() {
        super.detachView();
        if (mDisposable != null) mDisposable.dispose();
        Timber.tag(TAG).d("onDestroy lifecycle event. end ");
    }
    public void loadData(String key,String day){
        //检查View是否附着在上面，不在直接抛出异常
        checkViewAttached();
        //检查是否往下运行
        dispose(mDisposable);
        loadData(key,day,new BaseObserver<SMResponse<ArrayList<TodayBean>>>(new SubscriberListener<SMResponse<ArrayList<TodayBean>>>() {

            @Override
            public void onSubscribe(Disposable disposable) {
                super.onSubscribe(disposable);
                mDisposable = disposable;
            }

            @Override
            public void onSuccess(SMResponse<ArrayList<TodayBean>> response) {
                getMvpView().getDataSuccess(response.result);
            }

            @Override
            public void onFail(String errorCode, String errorMsg) {
                getMvpView().getDataFail(errorCode,errorMsg);
            }

            @Override
            public void onError(Throwable e) {
                getMvpView().onError(e);
            }
        }));
    }
    public void loadData(String key, String day, BaseObserver observer) {
        Observable<SMResponse<ArrayList<TodayBean>>> today = mIRemoteServer.getToday(key, day);
        today.observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(observer);
    }
}
复制代码
  • 在Activity中的使用,只需要使用这样使用，我们就能够检测到生命周期的使用，有兴趣的可以下载Apk查看日志！
    private NewNetWorkPresenter mNewNetWorkPresenter;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_new_net_work);
        mNewNetWorkPresenter = new NewNetWorkPresenter();
        getLifecycle().addObserver(mNewNetWorkPresenter);
   
    }
复制代码
  • Lifecycle的升级使用
  • 假如我们有个这样的需求，某个页面需要去查询数据库展示数据，同时使用到RxJava2的依赖,查询数据的过程在子线程处理数据回调到UI线程，当突然有一天产品经理说这个页面的数据我们要从网络获取，那么你也不确定那到底是把代码删除了还是备份，这些你都不知道！所以这时候你就需要独立绑定getLifecycle().addObserver(mSyncLifecycleObserver);Activity只关心结果即可！代码如下
  • 在这里需要使用这个依赖
  api  "com.jakewharton.rxrelay2:rxrelay:2.0.0"
复制代码

  • SyncResponse
public class SyncResponse {
    public final SyncResponseEventType eventType;
    public final Events comment;

    public SyncResponse(SyncResponseEventType eventType, Events comment) {
        this.eventType = eventType;
        this.comment = comment;
    }
}
复制代码
  • SyncLifecycleObserver

package com.shiming.hement.lifecycle;

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
import android.widget.Toast;

import com.shiming.hement.utils.Events;

import org.w3c.dom.Comment;

import io.reactivex.Completable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import timber.log.Timber;

/**
 * <p>
 *
 * </p>
 *
 * @author shiming
 * @version v1.0
 * @since 2018/12/18 10:44
 */

public class SyncLifecycleObserver implements LifecycleObserver {

    private static final String TAG = "SyncLifecycleObserver";

    private final CompositeDisposable disposables = new CompositeDisposable();


    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Timber.tag(TAG).d("onCreate lifecycle event.");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Timber.tag(TAG).d("onStart lifecycle event.");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Timber.tag(TAG).d("onResume lifecycle event.");
        disposables.add(SyncRxBus.getInstance().toObservable()
                .subscribe(new Consumer<SyncResponse>() {
                    @Override
                    public void accept(SyncResponse syncResponse) throws Exception {
                        handleSyncResponse(syncResponse);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Timber.tag(TAG).d("onResume lifecycle event.  Throwable=  %s",throwable);
                    }
                }));
    }

    private void handleSyncResponse(SyncResponse response) {
        if (response.eventType == SyncResponseEventType.SUCCESS) {
            onSyncSuccess(response.comment);
        } else {
            onSyncFailed(response.comment);
        }
    }

    private void onSyncSuccess(Events comment) {
        Timber.tag(TAG).d("received sync comment success event for comment %s", comment);
        disposables.add(Completable.fromAction(new Action() {
            @Override
            public void run() throws Exception {
                doWhat();
                Thread thread = Thread.currentThread();
                Timber.tag(TAG).i(thread.toString());
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action() {
                               @Override
                               public void run() throws Exception {
                                   Timber.tag(TAG).d("  success");
                               }
                           },
                        new Consumer<Throwable>() {
                            @Override
                            public void accept(Throwable throwable) throws Exception {
                                Timber.tag(TAG).e(throwable, "  error");
                            }
                        }));
    }

    /**
     * 可以做些子线程的数据操作
     */
    private void doWhat() {

    }
    private void onSyncFailed(Events comment) {
        Timber.tag(TAG).d("received sync comment failed event for comment %s", comment);
        disposables.add(Completable.fromAction(new Action() {
            @Override
            public void run() throws Exception {
                doWhat();
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action() {
                               @Override
                               public void run() throws Exception {
                                   Timber.tag(TAG).d("  success");
                               }
                           },
                        new Consumer<Throwable>() {
                            @Override
                            public void accept(Throwable throwable) throws Exception {
                                Timber.tag(TAG).e(throwable, "  error");
                            }
                        }));
    }

    /**
     * 12-19 15:35:52.317 29721-29721/com.shiming.hement D/SyncLifecycleObserver: received sync comment success event for comment Events=我是NewRxBusDemoActivity中发出成功的事件
     * 12-19 15:35:52.318 29721-29834/com.shiming.hement I/SyncLifecycleObserver: Thread[RxCachedThreadScheduler-2,5,main]
     * 12-19 15:35:52.318 29721-29721/com.shiming.hement D/SyncLifecycleObserver: received sync comment success event for comment Events=我是NewRxBusDemoActivity中发出成功的事件
     * 12-19 15:35:52.319 29721-29835/com.shiming.hement I/SyncLifecycleObserver: Thread[RxCachedThreadScheduler-3,5,main]
     * 12-19 15:35:52.320 29721-29721/com.shiming.hement D/SyncLifecycleObserver: received sync comment success event for comment Events=我是NewRxBusDemoActivity中发出成功的事件
     * 12-19 15:35:52.321 29721-29834/com.shiming.hement I/SyncLifecycleObserver: Thread[RxCachedThreadScheduler-2,5,main]
     * 12-19 15:35:52.323 29721-29721/com.shiming.hement D/SyncLifecycleObserver:   success
     * 12-19 15:35:52.330 29721-29721/com.shiming.hement D/SyncLifecycleObserver:   success
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Timber.tag(TAG).d("onPause lifecycle event.");
        // 如果不在这里
        disposables.clear();
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Timber.tag(TAG).d("onStop lifecycle event.");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Timber.tag(TAG).d("onDestroy lifecycle event.");
    }

    /**
     * 所有的事件都会输出
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny() {
        Timber.tag(TAG).d("onAny 所有的事件都会输出");
    }
}

复制代码
  • SyncResponseEventType

public enum SyncResponseEventType {
    SUCCESS,
    FAILED
}

复制代码
  • SyncRxBus

public class SyncRxBus {

    private static SyncRxBus instance;
    private final PublishRelay<SyncResponse> relay;

    public static synchronized SyncRxBus getInstance() {
        if (instance == null) {
            instance = new SyncRxBus();
        }
        return instance;
    }

    private SyncRxBus() {
        relay = PublishRelay.create();
    }

    public void post(SyncResponseEventType eventType, Events comment) {
        relay.accept(new SyncResponse(eventType, comment));
    }

    public Observable<SyncResponse> toObservable() {
        return relay;
    }
}

复制代码
  • 在Activity中的使用
   // 如果使用的多的话，可以放在BaseActivity中
    private SyncLifecycleObserver mSyncLifecycleObserver = new SyncLifecycleObserver();


    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rx_bus_layout);
        getLifecycle().addObserver(mSyncLifecycleObserver);

        findViewById(R.id.btn_mock_send_s_onclick).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Events events = new Events("我是NewRxBusDemoActivity中发出成功的事件");
                SyncRxBus.getInstance().post(SyncResponseEventType.SUCCESS, events);
            }
        });
        findViewById(R.id.btn_mock_send_f_onclick).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Events events = new Events("我是NewRxBusDemoActivity中发出失败的事件");
                SyncRxBus.getInstance().post(SyncResponseEventType.FAILED, events);
            }
        });
复制代码
weixin_33912638
关注
Lifecycle
蓝枫
01-14 287
Lifecycle 用于帮助开发者管理Activity和Fragment的生命周期 implementation "android.arch.lifecycle:extensions:1.1.1" package com.zhoujian.lifecycledemo.activity; import android.os.Bundle; import com.zhoujian.lif...
Jetpack架构组件库：Lifecycle、LiveData、ViewModel
川峰的博客
01-27 1489
LifecycleOwner 是单一方法接口，表示类具有 Lifecycle。它具有一种方法（即 getLifecycle()），该方法必须由类实现。 此接口从各个类（如 Fragment 和 AppCompatActivity）抽象化 Lifecycle 的所有权，并允许编写与这些类搭配使用的组件。任何自定义应用类均可实现 LifecycleOwner 接口。 实现 DefaultLifecycleObserver 的组件可与实现 LifecycleOwner 的组件完美配合，因为所有者可以提供生命周期
【AAC 系列二】深入理解架构组件的基石：Lifecycle
weixin_33929309的博客
05-13 160
0. 序言 你好，我是程序亦非猿，阿里巴巴资深客户端工程师一枚 本文是深入理解 AAC 系列的第二篇，第一篇请看这里：juejin.im/post/5cd4ea… 在前文，我就提到 Android Architecture Components （后简称为 AAC），是一个帮助开发者设计 健壮、 可测试且 可维护的一系列库的集合。 Lifecycle 就是 AAC 中的一员，它能够...
Lifecycle 是项目构建的生命周期
hqmln的博客
11-04 156
Lifecycle 是项目构建的生命周期，它包括 9 个 Phase（阶段）      
Lifecycle 使用及原理解析 一文搞懂
潇风寒月
03-13 6851
Lifecycle是Android Architecture Components的一员,这玩意儿挺方便的,它是能感知Activity和Fragment的生命周期的. 一、使用Lifecycle 1. 引入Lifecycle 我们来看一下如何引入: 非androidX项目引入: //运行时 implementation &quot;android.arch.lifecycle:runtime:1.1.1...
java8stream源码-mvvmArch:MVVM架构演示。Lifecycle+Retrofit+Room可以快速构建项目
06-04
安卓项目的开发结构，有原来最初的mvc，到后来有人提出的mvp，然后到mvvm的发展，无非就是依着六大设计原则的不断解耦，不断演变，使得项目的开发高度组件化，满足日常复杂多变的项目需求。 依赖倒置原则－...
解决maven中只有Lifecycle而Dependencies和Plugins消失的问题
08-18
在使用Apache Maven构建Java项目时，开发者可能会遇到一个棘手的问题：在IntelliJ IDEA (例如版本2019.2.2) 的Maven Projects工具窗口中，只有生命周期（Lifecycle）显示，而依赖（Dependencies）和插件（Plugins）...
解决flutter 错误: 程序包androidx.lifecycle不存在问题
09-07
主要介绍了解决flutter 错误: 程序包androidx.lifecycle不存在问题,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
android-androidx-lifecycle-process：基于Android JetPack'androidx.lifecycle：lifecycle-process'AAR版本的Eclipse库项目
03-04
android-androidx-lifecycle-process Eclipse库项目基于： 进口： 文件>导入...>团队>团队项目集> URL： 要求： Android 9 (API 28) SDK Platform 参考：
LifeCycle在项目的简单用法
大模型学习路线
03-15 116
LifeCycle在项目的简单用法
Lifecycle你真的懂了吗？
gg199402的博客
04-06 398
Lifecycle生命周期感知型组件，用来执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。 本文Lifecycle版本为2.2.0： implementation ‘androidx.lifecycler:lifecycle-common:2.2.0’ //22.2.23 更新 2.5 ，2.2是用的比较多的版本 你真的了解Lifecycle了吗？ Lifecycle使用非常非常简单。默认你已经使用过Lifecycle。但如果我问你以下几个问题。你能回答出
Lifecycle详细分析
杨充
03-09 2251
Lifecycle源码分析 目录介绍 01.Lifecycle的作用是什么 02.Lifecycle的简单使用 03.Lifecycle的使用场景 04.如何实现生命周期感知 05.注解方法如何被调用 06.addObserver调用分析 07.知识点梳理和总结一下 00.使用AAC实现bus事件总线 利用LiveData实现事件总线，替代EventBus。充分利用了生命周期感知功能，可以在...
Lifecycle-生命周期感知型组件
钟小明的专栏
10-26 200
简介 Lifecycle是Google推荐的架构组件之一. 生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。 通过使用生命周期感知型组件，您可以将依赖组件的代码从生命周期方法移入组件本身中。 我们来描述一种业务场景来帮助我们更好的理解上面这段话的意义。 当我们的Activity中使用了自定义的播放器组件时，我们通常需要在Activity的onResume和onPause中
Lifecycle的简单使用
TI_ZJW的博客
12-20 342
文章目录一、Lifecycle是什么？二、示例 一、Lifecycle是什么？ Lifecycle 是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。 简单说是通过观察者模式+注解来让我们更方便的监听Activity和Fragment的生命周期变化。 LifeCycle的两个角色 LifeCycleOwner 生命周期拥有者，即Activity与Fragment（也可自定义，但局限性大） LifeCycleObserver 生命周期观察
Android 官方架构组件（一）——Lifecycle
weixin_34390105的博客
12-27 187
初到掘金，人生地不熟，喜欢的朋友，点个赞鼓励下新手呗~参考文章：https://mp.weixin.qq.com/s/VJif0D5PlrmyA1_emV-k0ghttps://mp.weixin.qq.com/s/jU-UHkRbiruBq6BcNOjr5w下面大量源码，请耐心点看~什么是Lifecycle？Lifecycle 组件指的是 android.arch.lifecycle 包下提...
Jetpack架构组件 （二）-- Lifecycle原理与使用
热门推荐
lixiong0713的博客
10-30 1万+
前言 本篇文章我们将来学习 Android Jetpack 架构组件中的 Lifecycle 组件。Lifecycle 组件是帮忙我们管理 Activity 和Fragment 的生命周期，也就是说，当 Activity 或者 Fragment 的生命周期发生变化的时候我们可以得到通知。我们通常会在生命周期方法中调用各种方法，这就导致生命周期相关方法代码比较臃肿，且耦合性高，不易维护。 1. 为什么需要Lifecycle 在应用开发中，处理 Activity 或者 Fragment 组件的生命周期相关代码是
Lifecycle使用及原理讲解
tangedegushi的博客
12-26 8154
Lifecycle是Google在2017年的IO大会上推出的 Android Architecture Components中的一个，这个组件的用处就是可以感知Activity的生命周期，先来看下它的简单使用： public class SecondActivity extends AppCompatActivity { private static final String TAG ...
Jetpack 之 LifeCycle
树叶的博客
09-07 168
Jetpack 之 LifeCycle 文章目录**Jetpack 之 LifeCycle**@[toc]**1. 使用意义****2. LifeCycle诞生的背景****3. LifeCycle可以做什么****4. 使用场景****5. 原理****6. Activity 与 Fragment中的使用****7. Lifecycle在Service中的使用****8. Lifecycle在Application中的使用** 1. 使用意义 Lifecycle完美解决了组件对页面生命周期的依赖问题，使组
unityiap unityearlytransactionobserver:registered for lifecycle event
最新发布
07-16
总之，unityiap unityearlytransactionobserver:registered for lifecycle event 是Unity IAP中的一个类，用于注册并监听应用的生命周期事件，并在交易相关的生命周期事件发生时，执行相关的逻辑和操作。通过该类的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值