精华内容
下载资源
问答
  • android生命周期_Android活动生命周期– 7个阶段和功能
    千次阅读
    2020-07-05 18:34:52

    android生命周期

    Activity is one of the primary components of an Android application. In this tutorial, we’ll be looking at the android activity lifecycle, and the various functions invoked in the different stages of an Activity’s runtime.

    活动是Android应用程序的主要组件之一。 在本教程中,我们将研究android Activity的生命周期,以及在Activity运行时的不同阶段调用的各种函数。

    Android活动生命周期流程图 (Android Activity Lifecycle Flow Diagram)

    An Activity is a single focused thing that the user can see. Let’s see how the lifecycle of an Activity looks like, which functions are triggered when and why, through a flow diagram.

    活动是用户可以看到的唯一关注的事物。 让我们看看活动的生命周期如何,通过流程图何时何地触发了哪些功能。

    Android活动生命周期阶段 (Android Activity Lifecycle Stages)

    The android activity goes through following lifecycle stages.

    android活动将经历以下生命周期阶段。

    • Create

      创造
    • Start

      开始
    • Pause

      暂停
    • Resume

      恢复
    • Stop

      停止
    • Restart

      重新开始
    • Destroy

      破坏

    There are specific callback functions for each of these lifecycle stages.

    每个生命周期阶段都有特定的回调函数。

    Android活动生命周期功能 (Android Activity Lifecycle Functions)

    Let’s look at the lifestyle functions of an activity.

    让我们看一下一项活动的生活方式功能。

    1. onCreate() (1. onCreate())

    This is the first stage of an activity lifecycle. This function is called when the activity is initialized.

    这是活动生命周期的第一阶段。 活动初始化时将调用此函数。

    In our Kotlin Activity class, the following function defines onCreate():

    在我们的Kotlin Activity类中,以下函数定义了onCreate()

    fun onCreate(savedInstanceState: Bundle?)

    We’ll look at what the bundle value contains in a later section.

    我们将在后面的部分中查看bundle的值。

    2. onStart() (2. onStart())

    In this lifecycle stage, the activity is ready to process. This function is called when the activity comes into the foreground but it isn’t interactive yet.

    在此生命周期阶段,活动已准备就绪。 当活动进入前台但尚未交互时,将调用此函数。

    3. onResume() (3. onResume())

    This is where the activity is executing. This function is called when the user is interacting with the activity.

    这是活动执行的地方。 当用户与活动进行交互时,将调用此函数。

    4. onPause() (4. onPause())

    This function is called when the user interaction with the activity isn’t possible.

    当用户无法与活动进行交互时,将调用此函数。

    Common scenarios: An incoming call comes up. Another application pops up. With the introduction of Android N and the multi-window feature, multiple apps are visible on the screen at one time. Apps that are not in focus would have the onPause() method triggered.

    常见情况 :出现来电。 弹出另一个应用程序。 引入Android N和多窗口功能后,一次可在屏幕上看到多个应用程序。 没有重点关注的应用将触发onPause()方法。

    5. onStop() (5. onStop())

    This function gets triggered when the activity is no longer visible and it has stopped working.

    当活动不再可见并且已停止工作时,将触发此功能。

    6. onDestroy() (6. onDestroy())

    This function gets triggered when the activity is destroyed.

    活动销毁时将触发此函数。

    Common scenarios: A new activity starts and the current activity is killed. For example, pressing back button to exit the application.

    常见情况 :新活动开始,当前活动被终止。 例如,按返回按钮退出应用程序。

    7. onRestart() (7. onRestart())

    This function gets triggered whenever the activity starts after being stopped. It differs from onStart() in the fact that it won’t be called when the activity launches for the first time. In the later stages, it’ll always be called before onStart().

    停止活动后,只要活动开始,就会触发此功能。 它与onStart()不同之处在于,在活动首次启动时不会调用它。 在后面的阶段中,将始终在onStart()之前onStart()它。

    保存和还原活动状态 (Saving and Restoring Activity States)

    Android provides us with a pair of functions : onSaveInstanceState() and onRestoreInstanceState().

    Android为我们提供了一对函数: onSaveInstanceState()onRestoreInstanceState()

    Following are the major scenarios when your activity’s state is saved.

    以下是保存活动状态的主要方案。

    1. When onStop() is triggered.

      触发onStop()
    2. On configuration changes such as screen rotations, changes in screen sizes. Android N has multi-window features, so user often changes the window size of the applications.

      在配置更改(例如屏幕旋转)时,屏幕尺寸也会更改。 Android N具有多窗口功能,因此用户经常更改应用程序的窗口大小。

    Configuration changes generally trigger the application to recreate the current activity by destroying the current view to draw it again. We need to save the current state of the activity in the onSaveInstanceState() function as shown below.

    配置更改通常会通过破坏当前视图以再次绘制来触发应用程序重新创建当前活动。 我们需要将活动的当前状态保存在onSaveInstanceState()函数中,如下所示。

    override fun onSaveInstanceState(outState: Bundle?) {
            super.onSaveInstanceState(outState)
        }

    The Bundle object stores the field values from the activity in the form of key/value pairs.

    Bundle对象以键/值对的形式存储活动中的字段值。

    The Bundle object is of the type nullable to prevent NullPointerException, thanks to Kotlin.

    由于Kotlin,Bundle对象的类型可以为null,以防止NullPointerException。

    override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
            super.onRestoreInstanceState(savedInstanceState)
    }

    The onRestoreInstanceState() function is only called when a saved state exists.

    仅当存在保存状态时才调用onRestoreInstanceState()函数。

    Note: Android automatically takes care of saving and restoring Views that have a unique ID.

    注意 :Android会自动负责保存和还原具有唯一ID的视图。

    Hence in the below layout, only the value of TextView would be saved and restored.

    因此,在下面的布局中,将仅保存和恢复TextView的值。

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.constraint.ConstraintLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context="net.androidly.helloworldkotlin.MainActivity">
    
        <TextView
            android:id="@+id/textView"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello World!"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="CLICK ME"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toBottomOf="@+id/textView" />
    
    </android.support.constraint.ConstraintLayout>

    To disable saving the view’s state, set the attribute android:saveEnabled to false

    要禁用保存视图的状态,请将属性android:saveEnabledfalse

    For Custom Views we need to explicitly set setSavedEnabled(true) on the widget.

    对于自定义视图,我们需要在小部件上显式设置setSavedEnabled(true)

    Following code snippet demonstrates saving and restoring state in an activity.

    以下代码段演示了活动中的保存和恢复状态。

    import android.support.v7.app.AppCompatActivity
    import android.os.Bundle
    import kotlinx.android.synthetic.main.activity_main.*
    
    class MainActivity : AppCompatActivity() {
    
    
        var title = "This title variable would reset when the configuration is changed. Let's preserve it"
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            textView.setText(title)
        }
    
        override fun onSaveInstanceState(outState: Bundle?) {
            outState?.putString("title",title)
            super.onSaveInstanceState(outState)
        }
    
        override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
            textView.setText(savedInstanceState?.getString("title"))
            super.onRestoreInstanceState(savedInstanceState)
        }
    }

    The onRestoreInstanceState() function is called only when recreating activity after it was killed by the Android OS.

    onRestoreInstanceState()函数仅在被Android OS杀死活动后重新创建活动时才调用。

    Note: Alternatively, the saved instance values can be retrieved in the onCreate function too. But we’ll have to keep a null checker since the bundle object would be null when the activity is created for the first time.

    注意 :或者,也可以在onCreate函数中检索保存的实例值。 但是我们必须保留一个null检查器,因为在首次创建活动时,bundle对象将为null。

    override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            if (savedInstanceState != null) {
                textView.setText(savedInstanceState.getString("title"))
            } else
                textView.setText(title)
        }

    处理活动配置更改 (Handling Activity Configuration Changes Ourselves)

    We can set the android:configChanges attribute in the AndroidManifest.xml file to prevent recreating the activity on a configuration change.

    我们可以在AndroidManifest.xml文件中设置android:configChanges属性,以防止在配置更改时重新创建活动。

    <activity android:name=".MainActivity"
              android:configChanges="orientation|keyboardHidden|screenSize"
              android:label="@string/app_name">

    The following method gets triggered whenever any of the above configuration change happens.

    每当上述任何配置更改发生时,都会触发以下方法。

    override fun onConfigurationChanged(newConfig: Configuration?) {
            super.onConfigurationChanged(newConfig)
    }

    References: Google Docs

    参考资料: Google文件

    翻译自: https://www.journaldev.com/53/android-activity-lifecycle

    android生命周期

    更多相关内容
  • Android生命周期Demo

    2019-01-18 22:40:57
    Android生命周期Demo,根据第一行代码书籍编写,适合新手理解安卓的生命周期。
  • Android说明Activity生命周期代码例子。用于演示Activity组件从创建到销毁的完整生命周期,以及Activity在不同栈方式下的置换算法。
  • 二、代码 /activityLifeCycle_3Screen/AndroidManifest.xml <manifest xmlns:android=http://schemas.android.com/apk/res/android package=com.fry.activityLifeCycle_3Screen android:versionCode=1 android:...
  • Android代码测试Activity的生命周期

    千次阅读 2018-09-30 11:11:23
    代码测试Activity的生命周期 测试用例: 1)界面从“死亡”--&gt;“运行" (打开界面) 2) 界面从“运行”--&gt;“死亡" (点击返回键) 3) 界面从“运行”--&gt;“停止" (点击...

    Activity的生命周期图

    代码测试Activity的生命周期

    测试用例:

    1)界面从死亡”-->“运行" (打开界面)

    2) 界面从运行”-->“死亡" (点击返回键)

    3) 界面从运行”-->“停止" (点击home键)

    4) 界面从停止” -->“运行"(长按home键返回界面)

    5) 界面从运行”-->“暂停" (打开一个对话框)

    6) 界面从暂停” -->“运行"(从对话框返回)

    代码如下:

    import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.View;
     
    /**
     * 
     * @author Administrator
     1)界面从“死亡”-->“运行" 
        创建对象-->onCreate()-->onStart()-->onResume()---可见可操作(运行状态)
    2) 界面从“运行”-->“死亡" 
        onPause()-->onStop()-->onDestroy()-->Activity对象成为垃圾对象---不可见也不存在死亡状态)
    3) 界面从“运行”-->“停止" 
        onPause()-->onStop()---不可见但存在
    4) 界面从“停止” -->“运行"
        onRestart()-->onStart()-->onResume()
    5) 界面从“运行”-->“暂停" 
        onPause()
    6) 界面从“暂停” -->“运行"
        onResume()
        
       重要的:
       1. onCreate(): 在Activity对象创建后调用, 只执行一次
       2. onDestroy(): 在Activity死亡之前调用, 只执行一次
       3. onResume(): 界面只有经历此方法才能可见可操作
     */
    public class MainActivity extends Activity{
     
        public MainActivity() {
            Log.e("TAG", "MainActivity()");
        }
         
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            Log.e("TAG", "onCreate()");
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
         
        @Override
        protected void onStart() {
            Log.e("TAG", "onStart()");
            super.onStart();
        }
         
        @Override
        protected void onResume() {
            Log.e("TAG", "onResume()");
            super.onResume();
        }
         
        @Override
        protected void onPause() {
            Log.e("TAG", "onPause()");
            super.onPause();
        }
         
        @Override
        protected void onStop() {
            Log.e("TAG", "onStop()");
            super.onStop();
        }
         
        @Override
        protected void onRestart() {
            Log.e("TAG", "onRestart()");
            super.onRestart();
        }
         
        @Override
        protected void onDestroy() {
            Log.e("TAG", "onDestroy()");
            super.onDestroy();
        }
         
        public void startSecond(View v) {
            startActivity(new Intent(this, SecondActivity.class));
        }
    }
    

    Activity生命周期与状态

    注:此文章来自尚硅谷http://www.atguigu.com/课程学习资料总结

    展开全文
  • Android Activity生命周期演示源码,从第一个Activity到第二个Activity,Android Activity形象的说就是一个容器,在里面放置各种控件(按钮,文本,复选框等),就形成了软件的界面~ Activity是可见的。
  • 关于Activity生命周期和横竖屏切换时,生命周期的执行过程,网上有很多文章。但是都写的很模糊,并且不完善。一般的我们去切换屏幕方向都是不希望Activity被重新创建,这时就需要对一些属性进行设置,或者使用代码...
  • android activity生命周期示例代码。里面包含activity执行finish之后的生命周期,旋转的生命周期。切换以及返回activity的生命周期。我的博客地址:http://blog.csdn.net/qq_16064871
  • 有助于深入了解Android Activity生命周期的测试代码,可以结合博客http://blog.csdn.net/freetangxiaoying/article/details/17167819领悟。
  • 浅谈Android生命周期

    2016-08-16 13:11:06
    不建议下载代码,博客有详细的说明,博客地址:http://blog.csdn.net/qq_16497617/article/details/52215065#
  • 主要介绍了Android开发中Widget的生命周期,结合实例形式分析了Android开发中Widget生命周期所涉及的常用方法与使用技巧,代码备有详尽的注释便于理解,需要的朋友可以参考下
  • Android Activity和Fragment的生命周期测试代码,没事的时候可以玩玩。
  • Android生命周期详解

    千次阅读 2020-07-30 15:15:32
    Android生命周期分为两部分: 一、典型情况下的生命周期。 二、异常情况下的生命周期。 一、典型情况下的生命周期 典型情况下的生命周期指在有用户参与的情况下,Activity所经过的生命周期的改变,正常情况下,...

    最近在看任玉刚老师的开发艺术探索,记录一下。
    Android生命周期分为两部分:
    一、典型情况下的生命周期。
    二、异常情况下的生命周期。

    一、典型情况下的生命周期

    典型情况下的生命周期指在有用户参与的情况下,Activity所经过的生命周期的改变,正常情况下,Activity的常用生命周期就只有下面七个。

    /*1.onCreate:
        每个Activity在写代码的过程中都会看见这个函数,
        是声明周期的第一个方法。
        一般做一些资源和数据初始化的工作,
        比如绑定相对应的资源布局setContentView*/
            @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
        
        
    /*2.onRestart:
        字面意思表示Activity重新启动,这个状态一般由用户切换应用的行为产生,
        比如从应用切换到桌面或者切打开新的Activity,
        此时这个Activity就会调用onPause和onStop让这个Activity进入展厅状态。
        再回到这个Activity就是onRestart了*/
            @Override
        protected void onRestart() {
            super.onRestart();
        }
        
        
    /*3.onStart:
        这个状态我理解就是Activity启动中的一个过程,
        就是启动中,但是还不能与用户交互(用户不可见),
        属于一个在后台的状态*/
            @Override
        protected void onStart() {
            super.onStart();
        }
        
        
    /*4.onResume:
        表示Activity已经可见,且已经开始活动。
        与onStart类似的状态但是就是属于一种在前台的状态*/
            @Override
        protected void onResume() {
            super.onResume();
        }
        
        
    /*5.onPause:
        是一个非常微妙的状态,处于正在停止的一个临界点,
        就很难重现这种状态,就是在停止过程中,
        先执行onPause然后在onStop执行之前,
        回到Activity执行onResume,这期间就是onPause的状态。
        此处可以做一些存储数据停止动画的工作,但是不能太耗时,
        不然会影响到新Activity的显示,只有这些操作做完,
        新Activity的OnResume才会执行。*/
            @Override
        protected void onPause() {
            super.onPause();
        }
        
        
    /*6.onStop:
        表示Activity即将停止,可以做一些相对重量级的回收工作,
        同样不能太耗时。*/
        @Override
        protected void onStop() {
            super.onStop();
        }
    
    /*onDestroy
        表示Activity即将被销毁,这是Activity生命的尽头,
        可以做一些回收工作和资源的释放。*/
        @Override
        protected void onDestroy() {
            super.onDestroy();
        }
    

    activity生命周期的切换过程
    1、onStart 和 onResume、onPause 和 onStop 从描述上看差不多,对我们来说有什么实质的不同呢?
       从实际使用过程中来说,onStart 和 onResume、onPause 和 onStop看起来的确差不多,甚至我们可以只保留一对,比如只保留 onState 和 onStop。既然如此,那为什么 Android系统还要提供看起来重复的接口呢?根据上面的分析,我们知道,这两个配对的回调分别表示不同意义,onState 和onStop 是从 Activity 是否可见这个角度来回调的,而 onResume 和 onPause 是从 Activity 是否位于前台这个角度来回调的,除了这种区别,在实际使用中没有其他明显区别。

    2.假设当前Activity为A,如果这时用户打开了一个新的活动B,那么B的onResume和A的onPause谁先执行呢?
       我们可以从Android源码里得到解释,A的onPause执行后B的onResume才会被调用。从另一个角度来说Android的官方文档中对onPause有这样一句解释:不能在onPause里进行重量级操作,因为必须在onPause执行过后,新的Activity才能Resume。

    二、异常情况下的生命周期

       onSaveInstanceState方法只会出现在 Activity被异常终止的情况下,它的调用时机是在 onStop之前,它和onPause方法没有既定的时序关系,可能在它之前,也可能在它之后。当 Activity被重新创建的时候, onRestoreInstanceState会被回调,它的调用时机是 onStart之后。系统只会在 Activity即将被销毁并且有机会重新显示的情况下才会去调用 onSaveInstanceState方法。当 Activity在异常情况下需要重新创建时,系统会默认为我们保存当前 Activity的视图结构,并且在 Activity重启后为我们恢复这些数据,比如文本框中用户输入的数据、listview滚动的位置等,这些 view相关的状态系统都会默认为我们恢复。具体针对某一个 view系统能为我们恢复哪些数据可以查看 view的源码中的onSaveInstanceState和 onRestoreInstanceState方法。
       关于保存和恢复 View 的层次结构,系统工作流程是: Activity 异常终止, Activity 调用 onSaveInstanceState 去保存数据,然后 Activity 会委托 Windows 去保存数据,接着 Window 再委托它上面的顶层容器去保存数据。顶层容器是一个 ViewGroup ,一般来说它很可能是 DectorView ,最后顶层容器再去通知它的子元素保存数据。(这是一种委托思想,上层委托下层,父容器委托子元素去处理事情,如 View 的绘制过程,事件分发都是采用类似的思想)

    展开全文
  • fragment 代码示例
  • 大家好,今天给大家详解一下Android中Activity的生命周期,我在前面也曾经讲过这方面的内容,但是像网上大多数文章一样,基本都是翻译Android API,过于笼统,相信大家看了,会有一点点的帮助 ,但是还不能完全吃透...
  • 咱们以TextView控件为例: ...public class TestTextView extends android.support.v7.widget.AppCompatTextView { public TestTextView(Context context) { super(context); Log.e("TestTextView","TestTextView

    咱们以TextView控件为例:

    /**
     * Created by SunshineBoy on 2020/9/23.
     */
    public class TestTextView extends android.support.v7.widget.AppCompatTextView {
        public TestTextView(Context context) {
            super(context);
            Log.e("TestTextView","TestTextView(Context context)");
        }
    
        public TestTextView(Context context, @Nullable AttributeSet attrs) {
            super(context, attrs);
            Log.e("TestTextView","TestTextView(Context context, @Nullable AttributeSet attrs)");
        }
    
        public TestTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
        }
    
        @Override
        protected void onVisibilityChanged(View changedView, int visibility) {
            super.onVisibilityChanged(changedView, visibility);
            Log.e("TestTextView","onVisibilityChanged");
        }
    
        @Override
        protected void onFinishInflate() {
            super.onFinishInflate();
            Log.e("TestTextView","onFinishInflate");
        }
    
        @Override
        protected void onAttachedToWindow() {
            super.onAttachedToWindow();
            Log.e("TestTextView","onAttachedToWindow");
        }
    
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            Log.e("TestTextView","onMeasure");
        }
    
        @Override
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
            super.onSizeChanged(w, h, oldw, oldh);
            Log.e("TestTextView","onSizeChanged");
        }
    
        @Override
        protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
            super.onLayout(changed, left, top, right, bottom);
            Log.e("TestTextView","onLayout");
        }
    
        @Override
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);
            Log.e("TestTextView","onDraw");
        }
    
        @Override
        protected void onWindowVisibilityChanged(int visibility) {
            super.onWindowVisibilityChanged(visibility);
            Log.e("TestTextView","onWindowVisibilityChanged="+visibility);
        }
    
        @Override
        protected void onDetachedFromWindow() {
            super.onDetachedFromWindow();
            Log.e("TestTextView","onDetachedFromWindow");
        }
    }

    先看看默认状态下生命周期:

    2020-09-23 17:34:40.882 15132-15132/com.freddy.chat E/TestTextView: TestTextView(Context context, @Nullable AttributeSet attrs)
    2020-09-23 17:34:40.882 15132-15132/com.freddy.chat E/TestTextView: onFinishInflate
    2020-09-23 17:34:40.927 15132-15132/com.freddy.chat E/TestTextView: onAttachedToWindow
    2020-09-23 17:34:40.927 15132-15132/com.freddy.chat E/TestTextView: onWindowVisibilityChanged=0
    2020-09-23 17:34:40.927 15132-15132/com.freddy.chat E/TestTextView: onVisibilityChanged
    2020-09-23 17:34:40.928 15132-15132/com.freddy.chat E/TestTextView: onMeasure
    2020-09-23 17:34:41.056 15132-15132/com.freddy.chat E/TestTextView: onMeasure
    2020-09-23 17:34:41.056 15132-15132/com.freddy.chat E/TestTextView: onSizeChanged
    2020-09-23 17:34:41.056 15132-15132/com.freddy.chat E/TestTextView: onLayout
    2020-09-23 17:34:41.065 15132-15132/com.freddy.chat E/TestTextView: onDraw

    接下来看看setVisibility(View.INVISIBLE)状态:

    2020-09-23 17:37:14.191 15132-15132/com.freddy.chat E/TestTextView: onVisibilityChanged
    

    再看看setVisibility(View.VISIBLE)状态:

    2020-09-23 17:38:07.338 15132-15132/com.freddy.chat E/TestTextView: onVisibilityChanged
    2020-09-23 17:38:07.535 15132-15132/com.freddy.chat E/TestTextView: onDraw
    

    再看看离开Activity挂起状态:

    2020-09-23 17:39:33.128 15132-15132/com.freddy.chat E/TestTextView: onWindowVisibilityChanged=8
    2020-09-23 17:39:33.267 15132-15132/com.freddy.chat E/TestTextView: onVisibilityChanged

    然后Activity挂起恢复:

    2020-09-23 17:40:32.178 15132-15132/com.freddy.chat E/TestTextView: onWindowVisibilityChanged=4
    2020-09-23 17:40:32.361 15132-15132/com.freddy.chat E/TestTextView: onVisibilityChanged
    2020-09-23 17:40:32.414 15132-15132/com.freddy.chat E/TestTextView: onWindowVisibilityChanged=0
    2020-09-23 17:40:32.551 15132-15132/com.freddy.chat E/TestTextView: onDraw
    

    最后再看看Activity销毁状态:

    2020-09-23 17:41:31.610 15132-15132/com.freddy.chat E/TestTextView: onWindowVisibilityChanged=8
    2020-09-23 17:41:31.837 15132-15132/com.freddy.chat E/TestTextView: onDetachedFromWindow

    由上可知View的生命周期是:

    1. 首先创建带两个参数的构造函数;
    2. 然后从xml文件中inflate完成后调onFinishInflate方法;
    3. 然后在Activity执行onResume之后依附Activity窗口调onAttachedToWindow方法;
    4. 然后调窗口状态发生改变调onWindowVisibilityChanged方法;
    5. 然后调view的状态发生改变调onVisibilityChanged方法;
    6. 然后开始测量view尺寸调onMeasure方法;
    7. 然后测量结果与上次测量结果不一致时调onSizeChanged方法;
    8. 然后为子view分配位置调onLayout方法;
    9. 然后view渲染绘制内容细节调onDraw方法;
    10. 最后Activity销毁时调onDetachedFromWindow方法。

    欢迎关注微信公众号!你的每个赞和在看,都是对我的支持!👍在这里插入图片描述

    展开全文
  • 本篇文章主要介绍Android Activity的生命周期,这里整理了关于Activity的生命周期资料并附测试代码示例,有兴趣的小伙伴可以参考下
  • android生命周期

    2013-08-29 10:31:41
    Acitvity 生命周期代码示例,详细描述activity三种状态变化
  • 本文实例讲述了Android编程之基于Log演示一个activity生命周期。分享给大家供大家参考,具体如下: 利用Android的Log 演示一个activity的生命周期 代码: //DemoActivity.java package uni.activity; /* @author ...
  • Android说明Service生命周期代码例子。用于演示Service组件从创建到销毁的完整生命周期,以及IntentService的使用例子。
  •   Android程序启动后的第一个入口点是Application的onCreate(): public class MyApplication extends Application { @Override public void onCreate() { Log.d(TAG, &amp;quot;这里是Android程序入口&...
  • 主要介绍了Android学习系列二之窗口Activity的生命周期的相关资料,需要的朋友可以参考下
  • 什么是activity的生命周期? 即一个activity从启动到被销毁的过程称为activity的一个生命周期。 三种生命周期: 接下来将以一个案例来体验Activity的生命周期 一、设计要求: 1、主界面点击按钮跳转至界面2...
  • Android全面解析之Activity生命周期

    千次阅读 2020-11-08 21:32:50
    关于Activity生命周期的文章,网络上真的很多,有很多的博客也都讲得相当不错,可见Activity的重要性是非常高的。事实上,我猜测每个android开发者接触的第一个android组件都是Activity。我们从新建第一个Activity...
  • 4.3 Activity生命周期 ActivityLifeCycle.java文件的代码 4.3 Activity生命周期 ActivityLifeCycle.java文件的代码 通过在生命周期函数中添加日志点的方法调试程序的运行结果显示在LogCat中 为了显示结果易于观察和...
  • Android 生命周期例子

    2013-03-18 09:44:17
    andriod生命周期完整例子.是android开发中入门代码,对理解android 软件中事件的执行顺序有帮助。
  • Android LifeCycle监控生命周期

    千次阅读 2019-12-27 15:35:09
    LifeCycle的作用是感知组件(Activity/Fragment)的生命周期 , 并在合适的生命周期执行分配的任务. 1.监听组件生命后期 假设我们此时有一个Util类,其中有两个方法需要分别在Activity的onStart和onDestory的时候执行,...
  • Activity生命周期: **import androidx.appcompat.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; public class MainActivity extends AppCompatActivity { static String TAG =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,850
精华内容 45,540
关键字:

android生命周期代码