Android JetPack深入分析Lifecycle源码

已于 2023-07-04 10:55:49 修改
阅读量231 收藏
点赞数
分类专栏： JetPack 文章标签： android jetpack android
于 2023-07-03 19:05:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a734474820/article/details/131516238
版权

文章目录

前言

关键类介绍

Lifecycle

定义：用于存储有关组件（如 activity 或 fragment）的生命周期状态的信息，并允许其他对象观察此状态。

  • 它是一个抽象类，具体实现类为LifecycleRegistry；
  • 内部提供了addObserver(LifecycleObserver observer) 添加观察者、removeObserver(LifecycleObserver observer)移除观察者方法；
  • 内部封装了State【状态】、Event【事件】枚举类，以及一系列事件状态处理方法；
   @MainThread
    @NonNull
    public abstract State getCurrentState();

    public enum Event {
        ON_CREATE,
      
        ON_START,
      
        ON_RESUME,
       
        ON_PAUSE,
     
        ON_STOP,
       
        ON_DESTROY,
      
        ON_ANY;

      
        @Nullable
        public static Event downFrom(@NonNull State state) {
            switch (state) {
                case CREATED:
                    return ON_DESTROY;
                case STARTED:
                    return ON_STOP;
                case RESUMED:
                    return ON_PAUSE;
                default:
                    return null;
            }
        }

        @Nullable
        public static Event downTo(@NonNull State state) {
            switch (state) {
                case DESTROYED:
                    return ON_DESTROY;
                case CREATED:
                    return ON_STOP;
                case STARTED:
                    return ON_PAUSE;
                default:
                    return null;
            }
        }

 
        @Nullable
        public static Event upFrom(@NonNull State state) {
            switch (state) {
                case INITIALIZED:
                    return ON_CREATE;
                case CREATED:
                    return ON_START;
                case STARTED:
                    return ON_RESUME;
                default:
                    return null;
            }
        }

        @Nullable
        public static Event upTo(@NonNull State state) {
            switch (state) {
                case CREATED:
                    return ON_CREATE;
                case STARTED:
                    return ON_START;
                case RESUMED:
                    return ON_RESUME;
                default:
                    return null;
            }
        }

        @NonNull
        public State getTargetState() {
            switch (this) {
                case ON_CREATE:
                case ON_STOP:
                    return State.CREATED;
                case ON_START:
                case ON_PAUSE:
                    return State.STARTED;
                case ON_RESUME:
                    return State.RESUMED;
                case ON_DESTROY:
                    return State.DESTROYED;
                case ON_ANY:
                    break;
            }
            throw new IllegalArgumentException(this + " has no target state");
        }
    }

    @SuppressWarnings("WeakerAccess")
    public enum State {
    
        DESTROYED,

        INITIALIZED,
        
        CREATED,
        
        STARTED,

        RESUMED;
		//传入的state是否存在
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

构成Activity生命周期的状态和事件，其对应关系图如下：
状态和事件对应关系图
由上图我们可以很容易理解其中定义的方法：

	//根据传入的state获取逆序【生命周期结束方向】需要向下移动的事件
     public static Event downFrom(@NonNull State state) {
            switch (state) {
                case CREATED:
                    return ON_DESTROY;
                case STARTED:
                    return ON_STOP;
                case RESUMED:
                    return ON_PAUSE;
                default:
                    return null;
            }
        }
		//根据传入的state获取逆序【生命周期结束方向】触发state的事件
        public static Event downTo(@NonNull State state) {
            switch (state) {
                case DESTROYED:
                    return ON_DESTROY;
                case CREATED:
                    return ON_STOP;
                case STARTED:
                    return ON_PAUSE;
                default:
                    return null;
            }
        }
        
		//根据传入的state获取正序【生命周期上升方向】需要向下移动的事件
		public static Event upFrom(@NonNull State state) {
            switch (state) {
                case INITIALIZED:
                    return ON_CREATE;
                case CREATED:
                    return ON_START;
                case STARTED:
                    return ON_RESUME;
                default:
                    return null;
            }
        }
        
	//根据传入的state获取正序【生命周期上升方向】触发state的事件
      public static Event upTo(@NonNull State state) {
            switch (state) {
                case CREATED:
                    return ON_CREATE;
                case STARTED:
                    return ON_START;
                case RESUMED:
                    return ON_RESUME;
                default:
                    return null;
            }
        }
LifecycleObserver

生命周期观察者,用来监听Activity生命周期变化;其子类常用的有DefaultLifecycleObserver、LifecycleEventObserver;

public interface LifecycleEventObserver extends LifecycleObserver {
	//生命周期变化回调
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
LifecycleOwner

具有生命周期的类，对应被观察者,提供获取getLifecycle()方法，ComponentActivity类实现该接口；

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}
LifecycleRegistry

Lifecycle类的具体实现类，于ComponentActivity内部创建，其内部持有LifecycleOwner引用，通过维护mState【当前状态】、mObserverMap【存储观察者对象】等变量实现生命周期同步以及分发；

关键类UML类图关系

Lifecycle UML类图
小结： LifecycleOwner作为被观察者，其被ComponentActivity实现，同时ComponentActivity内部持有LifecycleRegistry对象，其提供添加、移除观察者LifecycleObserver方法，而从持有注册的观察者集合，一旦Activity生命周期变化时，LifecycleOwner便会触发LifecycleRegistry对象中的方法，并由LifecycleRegistry将事件分发给注册的观察者们；

观察者注册

注册观察者，最终调用的是LifecycleRegistry.addObserver方法，如下：


 private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
 	//当前生命周期状态
    private State mState;
 	//持有的LifecycleOwner
    private final WeakReference<LifecycleOwner> mLifecycleOwner;
	
    private int mAddingObserverCounter = 0;

    private boolean mHandlingEvent = false;
	
    private ArrayList<State> mParentStates = new ArrayList<>();


  public void addObserver(@NonNull LifecycleObserver observer) {
 		 //先进行线程校验，确保执行在主线程中；
        enforceMainThreadIfNeeded("addObserver");
        //如果当前mState状态是DESTROYED，则initialState赋值为DESTROYED，否则设置为INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED; 
        //将观察者observer和initialState保存成ObserverWithState对象，内部又会将observer包装成LifecycleEventObserver，以便后续进行Event分发；
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //mObserverMap是支持在遍历过程中进行添加、删除操作，内部持有HashMap对象；
        //以LifecycleObserver为K，Entry<LifecycleObserver,ObserverWithState>为Value进行存储，其中Entry<LifecycleObserver,ObserverWithState>是双向链表结构；
        //可以简单理解成 内部存储了【所有观察者以及其对应State】的集合！！！
		
		//1.先以LifecycleObserver为K进行查找，如果查找到，返回对应的ObserverWithState对象，否则按键值对存储，返回null
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        //2.当previous!=null，说明之前已存储过，不必进行后续事件处理
        if (previous != null) {
            return;
        }
        //mLifecycleOwner在LifecycleRegistry构造方法中初始化，是个虚引用，这里获取主要是为了检查LifecycleOwner是否已被回收	
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
        	//如果获取不到LifecycleOwner对象，则直接返回
            return;
        }
		//当前是否处于添加上一个observer 的状态下(即上一个observer的添加还没走完过程)|| 当前是否处于event事件处理中【主要是为了防止多次进行sync操作】
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        //3.计算新加入的LifecycleObserver需要同步的状态
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        //4. 当新加入的observer的mState小于目标状态时且observer没有被移除时，向observer分发生命周期事件
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
             //5.将当前statefulObserver.mState 的状态保存在mParentState集合中
            pushParentState(statefulObserver.mState);
            //6.根据状态获取下一个触发的事件
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }
            //7.分发事件给注册的statefulObserver，最终会回调`LifecycleEventObserver.onStateChanged方法`
            //这里需要注意下粘性事件问题，即使addObserver方法在onResume中调用，由于初始化时statefulObserver.mState为INITIALIZED，而mState已经为ON_RESUME，同样会分发ON_CREATE、ON_START事件~~~
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            //8.将当前statefulObserver.mState 的状态从mParentState集合中移除
            popParentState();
           //9.计算下一个需要同步的状态
            targetState = calculateTargetState(observer);
        }
		//10.当前不处于添加观察者、调度事件中，同步 state 给 所有observerWithState 并实现状态回调
        if (!isReentrance) {
            sync();
        }
        mAddingObserverCounter--;
    }



    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 = event.getTargetState();
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

其中sync()方法如下：

	//同步 state 给 所有observerWithState 并实现状态回调
    private void sync() {
  	  //1.先判断lifecycleOwner是否已被回收，如果回收则直接抛异常
        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.");
        }
 		//2.同步所有观察者状态，直到和mState一致;
        while (!isSynced()) {
            mNewEventOccurred = false;
            //mObserverMap中观察者们根据加入的顺序形成链表，新加入的位于链表结构的末尾；
            //3.如果mState比链表中第一个加入的观察者状态还小，说明所有观察者状态都大于mState，根据状态和事件对应图对应逆序方向，应该【向下更新】，例如【RESUMED-->ON_PAUSE】`backwardPass方法会倒序遍历链表进行事件分发`
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            //4.如果mState比链表中最后添加的观察者状态还大，说明所有观察者状态都小于mState，
            // 根据状态和事件对应图对应正序方向，应该【向上更新】，例如【CREATED-->ON_START】`forwardPass方法会正序遍历链表进行事件分发`
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

	//是否所有观察者状态都同步完毕
    private boolean isSynced() {
        if (mObserverMap.size() == 0) {
            return true;
        }
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }
	
	//【向上更新】，例如【CREATED-->ON_START】正序遍历链表进行事件分发
  private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                final Event event = Event.upFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event up from " + observer.mState);
                }
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

	//向下更新，例如【RESUMED-->ON_PAUSE】,倒序遍历链表进行事件分发
    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = Event.downFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event down from " + observer.mState);
                }
                pushParentState(event.getTargetState());
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

小结

  • LifecycleRegistry内部通过mObserverMap对象持有所有注册的观察者们，当调用addObserver方法添加新的观察者的时候，会设置初始化默认值为DESTROYED或INITIALIZED,与当前mState进行状态比较，不一致则进行状态同步以及生命周期事件分发，同时会判断当前是否处于添加观察者、调度事件中，如果不处于，会遍历所有注册的观察者进行事件同步分发操作；

生命周期分发

我们在androidx.core.app.ComponentActivity.onCreate方法中可以看到：

  protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }

其中ReportFragment.injectIfNeededIn(this):

    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            LifecycleCallbacks.registerIn(activity);
        }
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        	//模仿Glide生命周期管理，添加空白Fragment监听生命周期
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();   
            manager.executePendingTransactions();
        }
    }

这里我们重点看下LifecycleCallbacks.registerIn(activity)方法，其中LifecycleCallbacks类如下：

    @RequiresApi(29)
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

        static void registerIn(Activity activity) {
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
        }

        @Override
        public void onActivityCreated(@NonNull Activity activity,
                @Nullable Bundle bundle) {
        }

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }

        @Override
        public void onActivityStarted(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }

        @Override
        public void onActivityResumed(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }

        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }

        @Override
        public void onActivityPaused(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPreStopped(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_STOP);
        }

        @Override
        public void onActivityStopped(@NonNull Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(@NonNull Activity activity,
                @NonNull Bundle bundle) {
        }

        @Override
        public void onActivityPreDestroyed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_DESTROY);
        }

        @Override
        public void onActivityDestroyed(@NonNull Activity activity) {
        }
    }

因此当Activity生命周期变化的时候，会通过dispatch方法进行生命周期事件分发：

    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        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);
            }
        }
    }

dispatch方法中会调用LifecycleRegistry.handleLifecycleEvent(event)方法：

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        moveToState(event.getTargetState());
    }

	//进行状态同步，其中sync()方法我们上面已经分析过，其中会遍历所有存储的观察者进行生命周期事件分发
    private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            return;
        }
        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
    }

小结

生命周期分发流程整体比较简单，通过注册ActivityLifecycleCallbacks回调监听Activity生命周期变化，当生命周期变化时，最终会调用LifecycleRegistry.handleLifecycleEvent方法进行所有注册的观察者状态同步以及生命周期事件分发；

结语

如果以上文章对您有一点点帮助，希望您不要吝啬的点个赞加个关注，您每一次小小的举动都是我坚持写作的不懈动力！ღ( ´･ᴗ･` )

惜许
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jetpack——Lifecycle源码解析
GeofferySun的专栏
11-10 2912
一、Lifecycle是什么？ 传送门：Lifecycle 官网文档是学习最好的资料 Lifecycle 是构建生命周期感知型组件，这些组件可以根据 Activity 或 Fragment 的当前生命周期状态调整行为。生命周期感知型组件可执行操作来响应另一个组件的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。可以有效避免内存泄漏，解决Android生命周期常见难题。Lifecycle框架使用观察者模式监听被观察者的生命周期的变化。 Lifecycle 框架涉及
详解Jetpack 源码分析之Lifecycle 组件
weixin_43901866的博客
02-08 706
Jetpack 介绍 Jetpack 是一系列组件的集合，用于帮助开发者更加容易开发出高质量的 APP，这些组件帮助我们统一遵循最佳实践，这些最佳实践统一由组件实现，开发只需要使用这些组件即可，这样的话开发高质量的 App 就更加简单了。这些组件还可以帮助我们减少模板代码，简化复杂任务，让开发者更加专注于业务代码。 在 Android 开发者官网 中已经将 Jetpack、Kotlin、Andro...
Android JetPack深入分析LiveData源码
故不积跬步无以至千里
07-04 294
Google Android开发者 LiveData概览在了解LiveData源码之前，建议先了解LifeCycleAndroid JetPack深入分析Lifecycle源码定义LiveData是一种可观察的数据存储器类。与常规的可观察类不同，LiveData具有生命周期感知能力，意指它遵循其他应用组件（如 activity、fragment 或 service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。LiveData是一个数据存储类，能够感知。
Android JetPack 深入分析ViewModel源码
故不积跬步无以至千里
06-29 1511
本文主要分析ViewModel相关源码，相关使用不再赘述，可参考Android ViewModel使用；ViewModel 概览Google官方给的ViewModelViewModel类旨在 ` 以注重生命周期的方式存储和管理界面相关数据 `。ViewModel类 ` 让数据可在发生屏幕旋转等配置更改后继续留存 `。定义主要提到两个关键点：生命周期上图是Google官网提供的ViewModel生命周期图示，可以看到ViewModel的生命周期是从onCreate创建到完成并销毁Finished。
Android JetPack深入分析DataBinding源码
故不积跬步无以至千里
07-06 414
数据绑定库是一种支持库，借助该库，您可以使用声明性格式（而非程序化地）将布局中的界面组件绑定到应用中的数据源。支持双向绑定，数据变化的时候界面跟着变化，界面变化也同步给数据；在MVVM模式中使用比较多，双向绑定机制实现了View和Model的同步更新。通过APT技术于编译期生成相关辅助类，当调用方法时帮助我们完成布局控件绑定工作，减少操作，当调用数据更新操作时，数据作为被观察者，会绑定到虚引用对象上，更新过程中会使用Lifecycle进行生命周期判断，最终通过调用包下的辅助工具类完成控件更新操作；
Android Jetpack Components of Lifecycle 学习笔记
阿杜
08-11 353
Android Jetpack Components of Lifecycle 学习笔记 Android Jetpack Components of LiveData 学习笔记 Android Jetpack Components of ViewModel 学习笔记 都说天下文章一大抄。不过我不担心，我从来不抄袭别人的见解。 也有人说博客、GibHub 上 90% 的内容都是重复的。...
Jetpack Lifecycle 详解
txaz6的博客
06-17 796
不是标题党！作者会尽力把文章写的更容易理解也更充满深度，本文也随作者的持续学习，持续更新，有问题欢迎在评论区提出
一文搞懂Android-JetPack组件原理之Lifecycle、LiveData、ViewModel与源码分析技巧(1)
2401_84149733的博客
04-18 762
为了对分析工作有个感性认识，先过一下各个组件的作用和简单用法。LifecycleLifecycle可以方便我们处理Activity和Fragment的生命周期，可以将一些逻辑更加内聚和解耦，比如把资源的释放操作从Activity的回调代码中解耦出来，放到资源管理类中自动进行。该组件是后两个组件的基石，理解它的原理也有助于我们理解LiveData是如何保证不会造成内存泄漏的。下面是一个简单的使用示例，在自定义LifecycleObserver的实现接口上，用注解的方式声明与生命周期相关联的方法。
Android Jetpack从入门到精通，干货满满
erhtre的博客
04-28 1031
11.1 Hilt - Jetpack 推荐的依赖注入类库11.2 Paging3 - 逐步加载和显示数据11.3 App Startup - 在应用启动时初始化组件11.5 更简单的动画 — core-animation 和 SeekableAnimatedVectorDrawable。
ViewModelDemo:“ Android Jetpack系列——ViewModel源码分析”文章示例代码-android
03-24
在这个"Android Jetpack系列——ViewModel源码分析"的文章示例代码中，我们将深入探讨ViewModel的工作原理及其在实际应用中的用法。 ViewModel的设计目标是解决传统Android开发中数据在屏幕旋转等生命周期事件后...
Android高级应用源码-data.zip
10-14
在Android开发领域，深入理解和分析高级应用的源码是提升技术能力的重要途径。"Android高级应用源码-data.zip"这个压缩包很可能包含了多个用于展示Android高级特性和最佳实践的项目。接下来，我们将针对可能包含的...
Android核心技术与实例详解源码
03-28
Android Jetpack是一组可组合的组件，包括Lifecycle、Room、DataBinding、Paging等，能提升开发效率和代码质量。 8. **测试与调试**：单元测试、集成测试、 Espresso UI测试是保证代码质量的重要手段。Android ...
Android studio sdk 源码 android-29
04-13
Android-29源码中包含了Jetpack组件的更新，如Room数据库、Lifecycle、Paging等。 10. **App Startup优化**： - Android-29引入了App Startup库，帮助开发者优化应用启动性能，减少冷启动时间。 11. **动态系统...
android应用开发详解 源码 全
08-21
在学习源码的过程中，我们还需要关注Android框架层的变化，例如Android Jetpack组件库的使用，包括Lifecycle、ViewModel、Room等，这些都是现代Android开发的必备工具。 最后，调试技巧也是源码学习的一部分，学会...
Android Jetpack Compose 一些资源途径
听我俩天的博客
06-28 269
Jetpack Compose 提供了丰富的基础UI组件，并且有详细的文档和示例可以参考。
Android 系统网络、时间服务器配置修改
最新发布
ange_li的博客
07-03 213
刷机国外android rom 修改配置的常用命令
Android 分区存储
xingyu19911016的博客
07-02 831
在 Android 11（API 30）及更高的版本中，如果申请了 MANAGE_EXTERNAL_STORAGE 权限，通常不需要再显示申请 WRITE_EXTERNAL_STORAGE 和 READ_EXTERNAL_STORAGE 权限，因为 MANAGE_EXTERNAL_STORAGE 权限已经允许应用全面的访问共享存储空间（包括读写权限）。从 Android 10 开始，对共享存储的读写权限变得更加严格，开发者可以选择是否使用分区存储，Android 11 中强制使用了分区存储。
android 国内下载Gradle源
听我俩天的博客
07-03 264
在中国使用 Gradle 时，可以配置使用一些国内的镜像源，以提高下载速度和稳定性。使用这些国内镜像源可以显著提高 Gradle 的下载速度。使用这些镜像源地址。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值