【Jetpack】lifecycle

最新推荐文章于 2024-09-18 11:19:13 发布
最新推荐文章于 2024-09-18 11:19:13 发布
阅读量105 收藏
点赞数
文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czZ__czZ/article/details/112648325
版权

【JetPack】lifecycle

一、LifeCycle基本使用

创建liftcycle实现类，实现LifecycleObserver 

public class TestLifeCycle implements LifecycleObserver {
    private static final String TAG = "test";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.d(TAG, "onCreate: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.d(TAG, "onStart: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.d(TAG, "onResume: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.d(TAG, "onPause: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.d(TAG, "onStop: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d(TAG, "onDestroy: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny() {
        Log.d(TAG, "onAny: ");
    }
}

然后通过调用监听实现对生命周期的监控

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);
        getLifecycle().addObserver(new TestLifeCycle());
    }
}

用法很简单，可以和mvp架构或者其他架构配合起来进行使用，下面来分析一下源码

从调用开始addObserver（），addObserver里面传递的是实现了LifecycleObserver 接口的类，所以大有可为啊，点进去查看一下他的引用

@MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

来到了LifecycleRegistry里面,在state里继续走

   @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);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }

   static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;
//here
        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

Lifecycling

 @NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }

        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }

        final Class<?> klass = object.getClass();
        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);
    }

ReflectiveGenericLifecycleObserver，这里看起来像是获取了什么东西

  ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

ClassesInfoCache，这里面的两个方法看到了我们是通过反射获取了传入进来的lifecycle的方法，然后筛选带有注解的方法，并将其存放在map里

  CallbackInfo getInfo(Class klass) {
        CallbackInfo existing = mCallbackMap.get(klass);
        if (existing != null) {
            return existing;
        }
        existing = createInfo(klass, null);
        return existing;
    }


  private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
        Class superclass = klass.getSuperclass();
        Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
        if (superclass != null) {
            CallbackInfo superInfo = getInfo(superclass);
            if (superInfo != null) {
                handlerToEvent.putAll(superInfo.mHandlerToEvent);
            }
        }

        Class[] interfaces = klass.getInterfaces();
        for (Class intrfc : interfaces) {
            for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
                    intrfc).mHandlerToEvent.entrySet()) {
                verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
            }
        }
        //here
        Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
        boolean hasLifecycleMethods = false;
        for (Method method : methods) {
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            if (annotation == null) {
                continue;
            }
            hasLifecycleMethods = true;
            Class<?>[] params = method.getParameterTypes();
            int callType = CALL_TYPE_NO_ARG;
            if (params.length > 0) {
                callType = CALL_TYPE_PROVIDER;
                if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                    throw new IllegalArgumentException(
                            "invalid parameter type. Must be one and instanceof LifecycleOwner");
                }
            }
            Lifecycle.Event event = annotation.value();

            if (params.length > 1) {
                callType = CALL_TYPE_PROVIDER_WITH_EVENT;
                if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                    throw new IllegalArgumentException(
                            "invalid parameter type. second arg must be an event");
                }
                if (event != Lifecycle.Event.ON_ANY) {
                    throw new IllegalArgumentException(
                            "Second arg is supported only for ON_ANY value");
                }
            }
            if (params.length > 2) {
                throw new IllegalArgumentException("cannot have more than 2 params");
            }
            MethodReference methodReference = new MethodReference(callType, method);
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
        }
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);
//here
        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        return info;
    }

到这里，我们看到了大概的使用原理，接下来去activity里寻找一下怎么跟随生命周期使用的

在FragmentActiviy里的ComponentActivity中

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

很熟悉Glide里面的隐藏fragment的操作，通过隐形的fragment来操作生命周期


    public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

接下来就要在reportFragment的生命周期分析，非常有共同点

 public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }

dispatch判断是否属于lifecyclerowner接口，当然了，AppcompatActivity默认是实现了这些方法

private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

点进去发现跳到了lifecycleRegistry

  public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

 private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
    }
private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

这里的代码就是拿到生命周期的状态，然后使用backwardPass以及farwardPass回调到onStateChanged

    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }


  static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
//注意这里的回调

            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

回调到这里

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

然后在ClasseesInfoCache里有引用，最终调用了mMethod.invoke。还记得么，我们之前在这里缓存下来的数据是lifecycle，取出来到这里使用反射的invoke来调用各种生命周期的方法。

  void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
            invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
            invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
                    target);
        }

 private static void invokeMethodsForEvent(List<MethodReference> handlers,
                LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
            if (handlers != null) {
                for (int i = handlers.size() - 1; i >= 0; i--) {
                    handlers.get(i).invokeCallback(source, event, mWrapped);
                }
            }
        }
    void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
            //noinspection TryWithIdenticalCatches
            try {
                switch (mCallType) {
                    case CALL_TYPE_NO_ARG:
                        mMethod.invoke(target);
                        break;
                    case CALL_TYPE_PROVIDER:
                        mMethod.invoke(target, source);
                        break;
                    case CALL_TYPE_PROVIDER_WITH_EVENT:
                        mMethod.invoke(target, source, event);
                        break;
                }
            } catch (InvocationTargetException e) {
                throw new RuntimeException("Failed to call observer method", e.getCause());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }

来个流程总结

看一下LifecycleRegister 类中的addObserver方法,这里你会发现生成了一个ObserverWithState，然后放入FastSafeIterableMap里，这个类是一个自定义列表，用于保存观察者并可在遍历期间处理删除/添加。

 

1、AppCompatActivity 实现了LifecycleOwner接口，同时持有实现了Lifecycle的LifecycleRegistry对象，这个对象就可以将其理解为观察者模式中的Observable，LifecycleRegistr聚合多个LifecycleObserver，生命周期改变时通知LifecycleObserver进行相应的方法调用。

2、AppCompatActivity 继承的extends androidx.core.app.ComponentActivity中的onCretae方法ReportFragment.injectIfNeededIn(this);就是在当前的Activity里添加一个ReportFragment。

3、再看ReportFragment的生命周期函数，你会发现都调用了dispatch()方法。

4、而dispatch()方法则会判断Activity是否实现了LifecycleOwner接口，如果实现了该接口就调用LifecycleRegister的handleLifecycleEvent()，这样生命周期的状态就会借由LifecycleRegistry通知给各个LifecycleObserver从而调用其中对应Lifecycle.Event的方法。这种通过Fragment来感知Activity生命周期的方法其实在Glide的中也是有体现的。

5、回到handleLifecycleEvent方法中，State next = getStateAfter(event);事件发生的时候，先得到当前activity应该出现的下一个状态

6、moveToState(next); mState = next;   更新现在的状态 sync();

     backwardPass(lifecycleOwner);逆推

     forwardPass(lifecycleOwner);正推

     从图表上分析 ，就是利用一个state的状态，来记录不同生命周期之后所对应的状态，然后，利用这个状态赋值给当前状态去更新同步

然后在backwardPass以及forwardPass方法里循环处理所有的观察者，也就是拿到其当前的状态，然后通过downEvent方法获取当前状态需要降级需要的事件。然后交个ObserverWithState的dispatchEvent方法处理。

下面这个图很好说明了不同状态切换下对应的当前state

可以参考文章里的状态的升降级  【JetPack】Lifecycle - 生命周期观察者的简单使用和原理分析

 

 static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

 

7、forwardPass(lifecycleOwner)方法中的细节  ---  ObserverWithState observer = entry.getValue();

    找到ObserverWithState 类

    调用mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);   生成观察者适配器

8、接下来就是调用onStateChanged(),来通知 实现了 LifecycleObserver的类，生命周期发生了变化

10、查看实现类 ReflectiveGenericLifecycleObserver.onStateChanged()

ReflectiveGenericLifecycleObserver的构造方法中就把presenter中的方法和注解保存了下来，再通过onStateChanged()进行生命周期的方法的调用

整体时序图

 

 

 

 

 

 

 

czZ__czZ
关注
Jetpack LifeCycle基本使用及原理解析
龚礼鹏的博客
08-31 301
1.LifeCycle的诞生 ①.解耦，创建可感知的生命周期组件。 ②.降低内存泄漏发生的可能性。 2.使用LifeCycle解耦页面与组件 2.1 案例分析 假设有这样一个需求，当用户打开界面即获取定位位置，通常写法是在Activity中各个声明周期进行相应的地理位置操作。使地理位置这个操作和Activity中的生命周期密不可分，耦合严重。 2.2 LifeCycle的原理 Jetpack提供两个类：LifecycleOwner(被观察者)和LifecycleObse...
Android官方架构组件:Lifecycle详解&原理分析
却把清梅嗅的博客
01-11 2万+
概述在过去的谷歌IO大会上，Google官方向我们推出了Android Architecture Components,其中谈到Android组件处理生命周期的问题，向我们介绍了Handling Lifecycles。同时，如何利用android.arch.lifecycle包提供的类来控制数据、监听器等的 lifecycle。同时，LiveData与ViewModel的 lifecy
Lifecycle的基本使用和原理
zhaonhui的博客
09-26 7376
AppCompatActivity实现了LifecycleOwner接口，该接口有一个getLifecycle()方法，实现了这个接口的类就可以作为一个被观察者，被观察者观察它生命周期。 @SuppressWarnings({"WeakerAccess", "unused"}) public interface LifecycleOwner { Lifecycle getLifecycle(); } 在AppCompatActivity中调用getLifecycle方法返回的是LifeCycle的
Lifecycle详细分析
杨充
03-09 2244
Lifecycle源码分析 目录介绍 01.Lifecycle的作用是什么 02.Lifecycle的简单使用 03.Lifecycle的使用场景 04.如何实现生命周期感知 05.注解方法如何被调用 06.addObserver调用分析 07.知识点梳理和总结一下 00.使用AAC实现bus事件总线 利用LiveData实现事件总线，替代EventBus。充分利用了生命周期感知功能，可以在...
Android 官方架构组件（一）——Lifecycle
code小生
01-17 2080
code小生,一个专注 Android 领域的技术平台公众号回复 Android 加入我的安卓技术群作者：刺目啊1199链接：https://juejin.im/post...
Android架构组件—Lifecycle
qq_24442769的博客
03-02 7091
概述 Lifecycle组件是LiveData和ViewModle的基础，包括LifecycleOwner、LifecycleObserver。所以先学习Lifecycle有助于后续理解架构组件。 为什么需要Lifecycle？ 在我们日常编码过程中，不可避免要和activity、fragment这些系统控制生命周期的组件打交道，在添加一系列功能的同时和这些组件生命周期绑定是完成一个优秀...
jetpack lifecycle
06-11
Jetpack Lifecycle 是 Android Jetpack 组件库中的一个组件，它提供了一种方便的方式来管理 Android 应用程序中组件的生命周期。 Lifecycle 可以感知应用程序组件（如 Activity 和 Fragment）的生命周期状态并执行...
jetpack lifecycle使用教程及其代码
02-20
您好，Jetpack Lifecycle旨在提供简化应用程序开发的实用程序库。它提供了像ViewModel、LiveData和LifecycleOwner这样的类，可以更轻松地处理活动和片段的生命周期管理。要使用Jetpack Lifecycle，您可以参考以下...
Android Jetpack架构组件Lifecycle详解
01-03
Lifecycle是Jetpack架构组件中用来感知生命周期的组件，使用Lifecycles可以帮助我们写出和生命周期相关更简洁更易维护的代码。 生命周期 生命周期这个简单而又重要的知识相信大家早已耳熟能详。假设我们现在有这样...
jetpack lifecycle使用
02-20
答案：Jetpack Lifecycle 是一个安全的应用程序架构，可以让你的应用程序快速地构建，维护和管理生命周期。它提供了一系列的API，可以帮助你在应用程序中管理组件的状态，同时也可以让你保持稳定性，并减少代码量。
Android Liftcycle
Keep writing codes
09-17 904
As you'll learn in the following lessons, there are several situtations in which an activitytransitions between different states that are illustrated in figure 1. However, only three ofthese states ca
Lifecycle 使用及原理解析 一文搞懂
潇风寒月
03-13 6841
Lifecycle是Android Architecture Components的一员,这玩意儿挺方便的,它是能感知Activity和Fragment的生命周期的. 一、使用Lifecycle 1. 引入Lifecycle 我们来看一下如何引入: 非androidX项目引入: //运行时 implementation &quot;android.arch.lifecycle:runtime:1.1.1...
RxLifecycle的使用及源码解读
三荣君的博客
08-28 556
RxJava的使用 RxJava是一个基于观察者模式的异步开发库，通常我们在项目中结合Retrofit来执行网络请求，如下 HttpRepo.getUnReadMsgInfo(AppSetting.getInstance().getUserPhone()) .observeOn(AndroidSchedulers.mainThread()) .sub...
Android 架构组件（一）——Lifecycle
热门推荐
sd_zhuzhipeng的专栏
12-22 3万+
Android 架构组件（一）——Lifecycle-Aware Components 有一天“谷歌开发者”官微推送了《正式发布 Android 架构组件 1.0 稳定版 | 附带中文介绍视频》，发现这种架构足够秒杀MVP、MVVM，虽然之前的Google I/O大会中也介绍过，但是这次推出是稳定版，而且是可以投入到生产中去。于是就顺着这篇去官网看了使用文档——《Guide to App
Lifecycle使用及原理讲解
tangedegushi的博客
12-26 8145
Lifecycle是Google在2017年的IO大会上推出的 Android Architecture Components中的一个，这个组件的用处就是可以感知Activity的生命周期，先来看下它的简单使用： public class SecondActivity extends AppCompatActivity { private static final String TAG ...
【AAC 系列二】深入理解架构组件的基石：Lifecycle
weixin_33929309的博客
05-13 157
0. 序言 你好，我是程序亦非猿，阿里巴巴资深客户端工程师一枚 本文是深入理解 AAC 系列的第二篇，第一篇请看这里：juejin.im/post/5cd4ea… 在前文，我就提到 Android Architecture Components （后简称为 AAC），是一个帮助开发者设计 健壮、 可测试且 可维护的一系列库的集合。 Lifecycle 就是 AAC 中的一员，它能够...
002.android生命周期(Activity Liftcycle)
左耳的专栏
08-20 1202
android的生命周期我想是所有老师讲课的第一课吧。以前，我一直在想，我为什么要知道生命周期，我不知道它，可是我依旧可以写程序啊，为什么人们把生命周期看的这么重要。       其实，一个完整的程序，从它的出现到结束，就是一次生命。当你再开启的时候，似乎生命有进行了一场轮回。有没有一点感觉，我们好像可以主宰者一个生命。我想首先我们要先了解一下什么是生命周期。     顾名思义：生命周期：一个
在Android中fragment的生命周期
最新发布
LLZjiayou的博客
09-18 725
Fragment的生命周期非常类似于Activity，但是它有自己特有的生命周期方法（如），因为Fragment的视图可能会被销毁和重建。
【Android】【Bug】使用OSmdroid绘制轨迹断裂问题
每天不是在写bug就是在写bug的路上
09-14 1016
使用OSmdroid绘制轨迹断裂问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值