activity_activitythread - CSDN
activity 订阅
activity是Android组件中最基本也是最为常见用的四大组件之一。Android四大组件有Activity,Service服务,Content Provider内容提供,BroadcastReceiver广播接收器。 展开全文
activity是Android组件中最基本也是最为常见用的四大组件之一。Android四大组件有Activity,Service服务,Content Provider内容提供,BroadcastReceiver广播接收器。
信息
定    义
Android系统组件
外文名
Activity
activity概要说明
Activity是Android组件中最基本也是最为常见用的四大组件(Activity,Service服务,Content Provider内容提供者,BroadcastReceiver广播接收器)之一 [1]  。Activity是一个应用程序组件,提供一个屏幕,用户可以用来交互为了完成某项任务。Activity中所有操作都与用户密切相关,是一个负责与用户交互的组件,可以通过setContentView(View)来显示指定控件。在一个android应用中,一个Activity通常就是一个单独的屏幕,它上面可以显示一些控件也可以监听并处理用户的事件做出响应。Activity之间通过Intent进行通信。
收起全文
精华内容
参与话题
  • Activity 的介绍和使用(一)

    万次阅读 2020-04-28 17:57:41
    Activity是什么Activity是Android的四大组件之一。是用户操作的可视化界面;它为用户提供了一个完成操作指令的窗口。当我们创建完毕Activity之后,需要调用setContentView()方法来完成界面的显示;以此来为用户提供...

    Activity是什么

    Activity是Android的四大组件之一。是用户操作的可视化界面;它为用户提供了一个完成操作指令的窗口。当我们创建完毕Activity之后,需要调用setContentView()方法来完成界面的显示;以此来为用户提供交互的入口。在Android App 中只要能看见的几乎都要依托于Activity,所以Activity是在开发中使用最频繁的一种组件。

    Activity的生命周期

    在Android中会维持一个Activity Stack(Activity栈),当一个新的Activity创建时,它就会放到栈顶,这个Activity就处于运行状态。当再有一个新的Activity被创建后,会重新压人栈顶,而之前的Activity则会在这个新的Activity底下,就像子弹被压入枪梭一样。而且之前的Activity就会进入后台。

    一个Activity实质上有四种状态:

    1. 运行中(Running/Active):这时Activity位于栈顶,是可见的,并且可以用户交互。
    2. 暂停(Paused):当Activity失去焦点,不能跟用户交互了,但依然可见,就处于暂停状态。当一个新的非全屏的Activity或者一个透明的Activity放置在栈顶,Activity就处于暂停状态;这个时候Activity的各种数据还被保持着;只有在系统内存在极低的状态下,系统才会自动的去销毁Activity。
    3. 停止(Stoped):当一个Activity被另一个Activity完全覆盖,或者点击HOME键退入了后台,这时候Activity处于停止状态。这里有些是跟暂停状态相似的:这个时候Activity的各种数据还被保持着;当系统的别的地方需要用到内容时,系统会自动的去销毁Activity。
    4. 销毁(Detroyed):当我们点击返回键或者系统在内存不够用的情况下就会把Activity从栈里移除销毁,被系统回收,这时候,Activity处于销毁状态。

    上面的四种状态稍微笼统的介绍了一下Activity在不同时期的状态,下面我们通过具体的回调方法看一下Activity的生命周期,下面是官网提供的一张Activity在各个状态下回调用的回调方法:
    activity-lifecycle

    这张图包含了Activity从被创建到被销毁的几乎所有生命周期的回调函数。从上面的方法名我们就可以猜到其大概的功能。一会我们会细讲。我们上面说到了Activities的四种状态,但是这些方法是在什么状态下调用的呢?

    在Activity运行之前,会通过onCreate(),onStart(),onResume();当运行完onResume()之后,Activity就处于上面说的Running/Active 状态了。

    当Activity处于暂停状态时,会调用onPause(),这个时候Activity还是见的。当在这个时候Activity恢复到运行状态时,会重新调用onResume()。

    当Activity处理停止状态时,会调用onStop(),这个时候如果要恢复到运行状态就会调用一个新的方法onRestart(),然后去调用onStart(),onResume()。

    当Activity被销毁时,就会调用onDestroy(),那么如果要恢复Activity的显示就需要重新创建这个Activity;重新去走onCreate(),onStart(),onResume()这三个方法。

    虽然通过字面意思可以大概了解这些方法的作用,但是我们还是需要说一下,它们的具体功能。

    onCreate: 当Activity第一次被创建时调用。是生命周期开始的第一个方法。在这里我们可以做一些初始化的操作,比如:调用setContentView()方法去加载界面,绑定布局里的一些控件,初始化一些Activity需要用到的数据。之后会调用onStart方法.

    onStart:当Activity正在变为可见时调用。这个时候Activity已经可见了,但是还没有出现在前台还不能跟用户交互。可以简单理解为Actvity已经可见但是还没有出现在前台。之后会调用onResume.

    onResume:当Activity可以跟用户交互时调用,这个时候,这个Activity位于栈的顶部。跟onStart相比,它们都是表示Activity已经可见,但是onStart调用时Activity还在后台,而调用onResume时,Activity已经进入了前台,可以跟用户交互了。之后会调用 onPause.

    onPause:当Activity暂停时调用这个方法;在这里我们可以用来保存数据,关闭动画和其它比较耗费CPU的操作;但是在这里做的操作绝对不能耗时,因为如果当前Activity要启动一个新的Activity,这个新的Activity会在当前Activity执行完毕onPause之后才能进入可见状态。这个方法之后一般会调用的方法有onStop或者onResume.

    注意:在Android3.0之前,调用这个方法之后,Activity可能会在系统内存紧张时被系统回收。

    onStop:当Activity进入后台,并且不会被用户看到时调用。当别的Activity出现在前台时,或者Activity会被销毁时,调用此方法;在这个方法调用之后,系统可能会在内存不够的情况下回收Activity;在这个方法之后一般会调用onRestart或者onDestroy.

    onDestroy:这个方法是Activity生命周期中调用的最后一个方法。它会在Activity被销毁之前调用;Activity销毁原因一般是我们调用Activity的finish方法手动销毁,另一个就是系统在内存紧张的情况下去销毁Activity,以用来节省空间。我们可以通过方法 isFinishing 来判断Activity是否正在被销毁。

    onRestart:这个方法是在Activity处于停止状态后,又回到可视状态时调用。之后会调用onResume.

    以上是Activity的生命周期方法,除此之外Activity还有两个方法感觉大家也应该知道,虽然它们不属于Activity的生命周期方法。这俩方法是:onSaveInstanceStateonRestoreInstanceState。,

    onSaveInstanceState
    它不属于Activity的生命周期方法,不一定会被触发,但是当应用遇到意外情况,比如:内存紧张用户点击了Home键或者用户按下电源键关闭屏幕等这些情况,这时系统可能会去销毁Activity,这时这个方法就会被调用。这里强调的是系统去回收Activity,而不是我们去手动的销毁Activity。这个方法提供了一个Bundle对象,我们可以通过它来保存一些临时性的状态或者数据。通常这个方法只适合保存临时数据,如果需要数据的持久化保存等操作,还是要在onPause方法里执行才好。当 Activity再次被创建时,Activity会通过onCreate(Bundle)或者onRestoreInstanceState(Bundle)执行的时候,会将提供一个的Bundle对象来恢复这些数据。

    onRestoreInstanceState
    这个方法调用的前提是,Activity必须是被系统销毁了,在Activity被再次创建时它会在onStart()方法之后被调用。

    下面总结一下Activity的生命周期:

    正常情况下Activity的生命周期是:
    onCreate->onStart->onResume->onPause->onStop->onDestroy

    1. 对于一个正常的Activity,第一次启动,会依次回调以下方法:
      onCreate->onStart->onResume
    2. 当我们打开一个新的Activity或者点击Home键回到桌面后,会依次回调以下方法:
      onPause->onStop。

      上面提到过,如果新的Activity是透明的(采用的透明主题),当前的Activity不会回调onStop.
    3. 当我们再次回到原Activity,会依次回调以下方法:
      onRestart->onStart->onResume.
    4. 当我们点击返回键后,会依次回调以下方法:
      onPause->onStop->onDestroy.
    5. 当Activity被系统回收后,再次被打开,会跟第一次启动的时回调生命周期方法一样(不包含 onSaveInstanceState 和 onRestoreInstanceState)。
    6. 我们可以注意到 其中onCreate 跟 onDestroy 是相对的。一个创建一个销毁。并且其只可能被调用一次。按照这种配对方式,我们也可以看出 onStart跟onStop 是配对的,这两个方法可以被多吃调用。onResume 和 onPause 也是配对的,它们一个获取焦点和用户交互,一个正好相反。
    7. onStart和onResume,onPause和onStop,这两对方法在功描述差不多,那为什么还要重复存在呢?
      其实这两对方法分别代表不同的意义,onStart和onStop 是Activity是否可见的标志,而onResume和onPause是从Activity是否位于前台的标志,它们针对的角度不同。
    8. 在onPause里不能做耗时操作,因为如果要启动一个新的Activity,新的Activity必须要在前一个Activity的onPause 方法执行完毕之后才会启动的新的Activity。

    上面是正常情况下的生命周期方法调用,下面简单说一下异常情况下Activity的生命周期:

    在系统内存不够时会根据优先级杀死Activity。怎么判断Activity的优先级呢?

    1. 最高的优先级:在前台显示并且跟用户交互的Activity,优先级最高,
    2. 暂停状态的Activity优先级次之:如果Activity没有在前台,但是可见,不可与用户交互,比如弹出一个对话框等。
    3. 处于后台Activity优先级最低:执行了onStop方法的Activity优先级最低。它不可见,并且无法跟用户交互。

    当系统内存不足,就会按照优先级去销毁Activity,在销毁Activity时会额外的在onPause和onStop之间调用onSaveInstanceState;当要重新创建这个Activity 时,会在onStart方法之后调用onRestoreInstanceState方法。

    展开全文
  • Activity深入理解

    千次阅读 2018-09-28 11:54:26
    Activity生命周期 Activity的交互 Activity横竖屏切换 Activity的启动方式 Activity之间的数据交换 Activity的启动模式 Intent Flag启动模式 清空任务栈 监听Anctivity生命周期 Activity之Recreate   一...

    目录

    • Activity生命周期
    • Activity的交互
    • Activity横竖屏切换
    • Activity的启动方式
    • Activity之间的数据交换
    • Activity的启动模式
    • Intent Flag启动模式
    • 清空任务栈
    • 监听Anctivity生命周期
    • Activity之Recreate

     

    一、Activity生命周期


    OnCreate  创建Activity时调用 销毁以前只执行一次
    OnStart   打开Activity时调用
    OnResume  唤醒Activity时调用
    OnPaused  暂停Activity时调用
    OnStopped 停止Activity时调用
    OnDestroy 销毁Activity时调用

     

     

    在Application中可以监听所有Activity的生命周期

    registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
                @Override
                public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                }
    
                @Override
                public void onActivityStarted(Activity activity) {
                }
    
                @Override
                public void onActivityResumed(Activity activity) {
                }
    
                @Override
                public void onActivityPaused(Activity activity) {  
                }
    
                @Override
                public void onActivityStopped(Activity activity) {
                }
    
                @Override
                public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
                }
    
                @Override
                public void onActivityDestroyed(Activity activity) {
                }
            });

     

    二、Activity的交互


    当第一个Activity跳转到第二个Activity时,首先执行的是第一个Activity的OnPaused方法,然后执行第二个Activity的OnCreate、OnStart、OnResumed方法,等到第二个Activity完全加载完毕(可显示状态)以后才会执行第一个Activity的Onstopped方法,当然跳转过程不会使第一个Activity被销毁。

    当从第二个Activity返回到第一个Activity时,首先执行的是第二个Activity的OnPaused方法,然后调用第一个Activity的OnRestart方法、OnStart方法、OnResumed方法,最后第一个Activity已经加载完毕(可显示状态),调用第二个Activity的OnStopped、OnDestroy方法来销毁它。

     

    流程图

    三、Activity横竖屏切换


    Activity横竖屏切换时并不是直接实现了横屏效果,而是先销毁了原来的Activity,然后调用OnCreate、OnStart、OnResume方法来呈现一个新的Activity。

    因为Activity在横竖屏切换时会重新创建Activity这样会使原本的Activity的进度发生改变(例如播放器),所以有些情况下我们需要通过OnSaveInstanceState(Bundle outState)这个方法来保存一些数据。

    具体使用方法

    在OnSaveInstanceState(Bundle outState)方法中保存数据,面以String为例。

     

    @Override
    public void onSaveInstanceState(Bundle outState)
    {
            //一般用于保存当前状态信息
    	super.OnSaveInstanceState(outState);
    	outState.putString("key","value");
    }
    
    //我们看到OnCreate方法中有一个参数就是Bundle savedInstanceState
    //所以我们在OnCreate中来获取保存数据.
    if(savedInstanceState!=null)
    {
       String str = savedInstanceState.getString("key");
    }

    注意:OnSaveInstanceState方法是在OnPause方法执行以后才开始执行的。
     

    四、Activity的启动方式

     

    一、 直接启动

    1.方法一

     

    Intent intent = new Intent(MainActivity.this,SecondActivity.class);
    StartActivity(intent);
    

    2.方法二

     

    Intent intent = new Intent();
    ComponentName component = new ComponentName( MainActivity.this,SecondActivity.class);
    intent.setComponent(component);
    startActivity(intent);

     

    二、 匿名启动

    首先在Mainifest.xml文件中进行注册

    <activity android:name=".SecondActivity">
    	<intent-filter>
    		<action android:name="test"/>
    		<category android:name="android.intent.category.DEFAULT"/>
    	</intent-filter>
    </activity>

    然后在代码中调用

    Intent intent = new Intent();
    intent.setAction("test");
    startActivity(intent);

    使用于Activity的class文件不是来自于代码,而是来自于第三方文件时。或者启动一个系统Activity时使用(系统Activity我们不用在Mainifest.xml中进行注册)。
    注意:如果启动系统Activity需要设置一个Uri。

     

    Intent intent = new Intent();
    intent.setAction(Intent.ACTION_VIEW);
    Uri uri = Uri.parse("http://www.baidu.com");
    intent.setData(uri);
    startActivity(intent);

    五、Activity之间的数据交换

    一、跳转时传递数据

    (1)方法一

    Intent intent = new Intent(MainActivity.this,SecondActivity.class);
    intent.putExtra("name","db");//以键值对的方式传递
    StartActivity(intent);
    在SecondActivity的代码中获取数据
    Intent intent = getIntent();
    if(intent!=null)
    {
    	String name = intent.getStringExtra("name");
    }

    (2)方法二

    Intent intent = new Intent(MainActivity.this,SecondActivity.class);
    Bundle bundle = new Bundle();
    bundle.putString("name","db");
    intent.putExtras(bundle);
    StartActivity(intent);
    //在SecondActivity的代码中获取数据和方法一相同

    (3)当传递的类型比较多的时候,我们可以通过java类来传递

    public class User implements Serializable{
    	private String name;
    	private int age;
    	public User(String name,int age)
    	{
    		this.name = name;
    		this.age = age;
    	}
    }
    Intent intent = new Intent(MainActivity.this,SecondActivity.class);
    User user = new User("db",20);
    Bundle bundle = new Bundle();
    bundle.putSerializable("User",user);
    intent.putExtras(bundle);
    StartActivity(intent);
    

    在SecondActivity的代码中获取数据

    Intent intent = getIntent();
    if(intent!=null)
    {
    	User user = (User)intent.getSerializableExtra("User");
    }

    注意:Bundle传递数据时数据大小必须小于1M否则会抛出TransactionTooLargeException异常。

     

    二、回传数据

    这样我们需要一个回调方法来实现,当activity退出时,向上一个activity传递数据(MainActivity获取SecondActivity返回的数据)。

    设置数据

    Intent intent = new Intent();
    Bundle bundle = new Bundle();
    bundle.putString("name","db");
    intent.putExtras(bundle);
    SecondActivity.this.setResult(-1,intent);

    获取数据(系统提供了一个回调方法)

    //接收选择器选中的结果:放在需要接受数据的activity中
        @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            //在这里用switch判断requestCode或者resultCode的值
    	//然后通过Bundle取出数据
     	Bundle bundle = data.getExtras();
     	String name = bundle.getString("name");
            }
        }


    当我们需要回传数据时就不能使用startActivity(intent)来开启Activity了,需要使用startActivityForResult(intent,requestCode);//requestCode的值随意给不能重复。

     

    六、Activity的启动模式


    Activity的启动模式共四种:standard、singleTop、singleTask、singleInstance

    设置启动模式(在Manifest的activity中添加以下代码)

     

    android:launchMode="singleTask"

     

    standard(标准模式)是系统的默认模式(可以不指定)。

    singleTop(单栈顶模式)如果存在A-B-C三个Activity,启动D,则D会被创建形成A-B-C-D;如果是A-B-C-D,D是栈顶的情况下,再次启动D,则D不会被创建。

    singleTask(单例模式)如果不存在D(Activity)则创建D,否则把D调到栈顶(不重新创建)。使用singleTask启动模式可以用来退出整个应用:将主Activity设为singleTask模式,然后在要退出的Activity中转到主Activity,从而将主Activity只上的Activity都清除,然后重写主Activity的OnNewIntent方法,在方法中添加finish(),将最后一个Activity结束掉。

    singleInstance 与singleTask相似,不会重复创建Activity,但是该模式下创建Activity会被放到一个新的Task中。这种启动模式类似于浏览器,和浏览器的工作原理一致,singleInstance的Activity会出现在一个新的任务栈中,而且该任务栈只存在该Activity

     

    注意:如果在singleTop或者singleInstance的Activity中通过startActivityForResult方法来启动另一个Activity则系统会直接返回Activity.RESULT_CANCELED而不会去等待返回。




     

    七、Intent Flag启动模式

    • Intent.FLAG_ACTIVITY_NEW_TASK :这种启动模式启动的Activity都会被放入一个新的任务栈中,用于从Service启动Activity,因为Service和Activity并不在同一任务栈中
    • Intent.FLAG_ACTIVITY_SINGLE_TOP : 使用singleTop模式启动Activity
    • Intent.FLAG_CLEAR_TOP :使用singleTask模式来启动一个Activity
    • Intent.ACTIVITY_NO_HISTORY : 使用这种模式启动其他Activity后,该Activity就消失,将不会保留在Activity栈中。

     

    八、清空任务栈

    可以通过设置AndroidMainifest文件中<activity>标签的属性来实现

    • clearTaskOnLaunch :每次返回该Activity时,都将该Activity之上的所有Activity清楚掉。
    • finishOnTaskLaunch:作用于自己身上,当离开该Activity所处的Task,那么用户再返回时,该Activity就会被finish掉。
    • alwaysRetainTaskState :该Activity将不接受任何清除命令,一直保持在当前Task状态。

     

    九、监听Anctivity生命周期

        在Application中对Activity的生命周期进行注册,其监听的是所有activity的生命周期

     /**
         * 在application中监听所有aictivity的生命周期
         */
        public void setRegisterActivityLifecycleCallbacks() {
            registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
                @Override
                public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
    
                }
    
                @Override
                public void onActivityStarted(Activity activity) {
    
                }
    
                @Override
                public void onActivityResumed(Activity activity) {
                    
                }
    
                @Override
                public void onActivityPaused(Activity activity) {
                    
                }
    
                @Override
                public void onActivityStopped(Activity activity) {
    
                }
    
                @Override
                public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
    
                }
    
                @Override
                public void onActivityDestroyed(Activity activity) {
    
                }
            });
        }

     

    十、Activity之Recreate

    我们可以通过Activity的recreate方法来重建Activity,recreate多走了两个个方法onSaveInstanceState(Bundle outState)和onRestoreInstanceState(),即通过Bundle来绑定之前的状态。如果你在Activity的onCreate方法中添加了Fragment,在Activity执行recreate方法时也会多次创建重复的Fragment这样也会造成内存泄漏,其结局办法为,在Recreate之前我们可以先remove掉之前已经包含的Fragment。

       @Override
        public void recreate() {
            try {//避免重启太快 恢复
                FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
                for (Fragment fragment : fragmentAdapter.getFragmentsList()) {
                    fragmentTransaction.remove(fragment);
                }
                fragmentTransaction.commitAllowingStateLoss();
            } catch (Exception e) {
            }
            super.recreate();
        }
    

     

     

     

    展开全文
  • Activiti 工作流入门到大神

    万人学习 2018-10-22 21:38:05
    什么是流程、工作流作用、Activiti背景简介、Activiti流程设计器安装、Activity环境搭建、通过HelloWorld掌握 Activiti操作流程的步奏、常见API使用、流程部署管理(发布流程、查看流程定义、删除流程、查看流程附件)...
  • Activity详解

    千次阅读 2018-03-30 10:06:19
    一、Activity简述1、概念引入图1.1 Activity类图结构Activity作为Android的四大组件之一,Activity在Android系统中是以界面的形式进行体现。其中Activity实现了如Window.Callback, KeyEvent.Callback等接口用于与...

    一、Activity简述

    1、概念引入


    图1.1 Activity类图结构

    Activity作为Android的四大组件之一,Activity在Android系统中是以界面的形式进行体现。其中Activity实现了如Window.Callback, KeyEvent.Callback等接口用于与用户进行交互。

    2、源码释义

        An activity is a single, focused thing that the user can do. 
    

    一个界面是开发者可以操作的一个重点的独立事项。

        Almost all activities interact with the user, so the Activity class takes care of creating a window for you in which you can place your UI with setContentView(View). 
    

    几乎所有界面都可以与用户交互,所以Activity类负责为用户创建一个窗口,你可以在其中使用setContentView(View)放置UI。

        While activities are often presented to the user as full-screen windows, they can also be used in other ways: as floating windows (via a theme with windowIsFloating set) or embedded inside of another activity (using ActivityGroup). 
    

    虽然界面通常以全屏窗口的形式呈现给用户,但它们也可以以其他方式使用:作为浮动窗口(通过具有windowIsFloating集合的主题)或嵌入另一个活动(使用ActivityGroup)内部

        There are two methods almost all subclasses of Activity will implement:
    

    几乎所有的Activity子类都会实现两种方法:

        onCreate(Bundle) is where you initialize your activity. Most importantly, here you will usually call setContentView(int) with a layout resource defining your UI, and using findViewById(int) to retrieve the widgets in that UI that you need to interact with programmatically.
    

    onCreate(Bundle)是初始化界面的地方。最重要的是,在这里你通常会调用setContentView(int)和一个定义你的UI的布局资源,并且使用findViewById(int)来检索你需要以编程方式进行交互的那个UI中控件。

        onPause() is where you deal with the user leaving your activity.Most importantly, any changes made by the user should at this point be committed (usually to the ContentProvider holding the data).
    

    onPause()是你对于用户离开界面的处理。最重要的是,此时用户所做的任何更改都应该提交(通常发送给持有数据的ContentProvider。

        To be of use with Context.startActivity(), all activity classes must have a corresponding declaration in their package's AndroidManifest.xml.
    

    要使用Context.startActivity(),所有界面类必须在其包下的AndroidManifest.xml中具有相应的声明。


    二、Activity的生命周期

    1、Activity的生命周期图

    2、生命周期详解

    2.1、OnCreate()方法

        Called when the activity is first created. This is where you should do all of your normal static set up:
        create views, bind data to lists, etc. 
    

    在第一次创建活动时调用。 这是你应该完成所有常规静态设置的位置:创建视图,将数据绑定到列表等。

        This method also provides you with a Bundle containing the activity's previously frozen state, if there was one.Always followed by onStart().
    

    此方法还会为你提供一个包含Activity先前保存页面状态的Bundle对象(如果有的话)。总是跟着onStart()方法。

    2.2、OnRestart()方法

        Called after your activity has been stopped, prior to it being started again.
    

    在你的界面停止后调用,然后再次启动。

        Always followed by onStart()
    

    总是跟着onStart()

    2.3、OnStart()方法

        Called when the activity is becoming visible to the user.
    

    当界面对用户变得可见时调用。

        Followed by onResume() if the activity comes to the foreground, or onStop() if it becomes hidden.
    

    如果活动进入前台,则跟随执行onResume()方法,如果隐藏,则执行onStop()。
    此时,Activity实际上就已经可见了,但是还没有出现在前台,无法和用户进行交互。

    2.4、onResume()方法

        Called when the activity will start interacting with the user.
    

    当界面对用户变得可见时调用。

        At this point your activity is at the top of the activity stack, with user input going to it.Always followed by onPause().
    

    如果界面进入前台,则跟随onResume()方法,如果隐藏,则执行onStop()方法。
    此时,Activity已经可见,并且出现在前台并开始活动。要注意的是onStart()被执行时Activity显示在后台,只有当OnResume()被执行时Activity才显示到前台。

    2.5、onPause()方法

        Called when the system is about to start resuming a previous activity. This is typically used to commit unsaved changes to persistent data, stop animations and other things that may be consuming CPU, etc. Implementations of this method must be very quick because the next activity will not be resumed until this method returns.
    

    onPause()方法在系统即将开始显示之前的界面时调用。 这通常用于将未保存的更改进行保存,并保存为持久化数据,并且会执行例如停止动画和其他可能消耗CPU的内容等。此方法的实现必须非常快速,因为在此方法返回之前,下一个界面不会显示。

        Followed by either onResume() if the activity returns back to the front, or onStop() if it becomes invisible to the user.
    

    如果界面返回到前台,则跟随onResume();如果对用户不可见,则使用onStop()。

    • onPause()方法执行后,Activity界面切换为后台程序

    2.6、onStop()方法

        Called when the activity is no longer visible to the user, because another activity has been resumed and is covering this one. This may happen either because a new activity is being started, an existing one is being brought in front of this one, or this one is being destroyed.
    

    onStop()方法会在当界面对用户不再可见时调用,因为另一项界面正在显示并要去覆盖这个界面。 这可能是因为一项新的界面正在开始,其他的界面会被显示为前台界面,或者这个界面正在被摧毁。

        Followed by either onRestart() if this activity is coming back to interact with the user, or onDestroy() if this activity is going away.
    

    如果这个界面快速的回显与用户交互紧接着onRestart()会被执行,否则,这个界面回销毁onDestroy()方法会被执行。

    2.6、onDestroy()方法

        The final call you receive before your activity is destroyed. This can happen either because the activity is finishing (someone called finish() on it, or because the system is temporarily destroying this instance of the activity to save space. You can distinguish between these two scenarios with the isFinishing() method.)
    

    在你的界面被销毁前被最后调用的方法。 这可能是因为界面正在结束(有人在其中调用finish()方法因为系统会暂时销毁此Activity界面的实例以节省空间,你可以使用isFinishing()方法区分内存空间是否节省资源的这两种情况)。



    3、异常情况下生命周期详解

    3.1、横竖屏切换时Activity的生命周期

    此时的生命周期跟清单文件里的配置有关系。
    不设置 Activity 的 android:configChanges 时,横竖屏切换会重新调用各个生命周期,销毁当前 activity,然后重新加载,跟系统配置有关。
    onSaveInstanceState()方法会在当前页面销毁前被调用存储数据onRestoreInstanceState()方法会被执行去取出保存的Bundle对象中的内容,进行一次横竖屏切换时Activity所执行的生命周期方法以及在onSaveInstanceState与onRestoreInstanceState打印相应日志,如下图所示:

    ③对于onRestoreInstanceState()方法,源码中的注释如下:

          This method is called after onStart when the activity is being re-initialized from a previously saved state, given here in savedInstanceState.  
    

    当这个界面从之前保存的状态重新初始化时,这个方法在onStart之后被调用,这里在savedInstanceState中给出。

          Most implementations will simply use onCreate to restore their state, but it is sometimes convenient to do it here after all of the initialization has been done or to allow subclasses to decide whether to use your default implementation.  The default implementation of this method performs a restore of any view state that had previously been frozen by onSaveInstanceState.
    

    大多数时,可以直接从onCreate()方法中的Bundle对象从中获取内容来恢复之前的页面状态,但有时在完成所有初始化或允许子类决定使用默认实现之后,在此处执行重新获取已存储数据的操作很方便。 此方法的默认实现会还原之前由onSaveInstanceState保存的任何视图状态。
    根据源码可以得知onRestoreInstanceState 方法的默认实现会还原之前由onSaveInstanceState保存的任何视图状态。

    三、Activity任务与任务管理栈

    1、任务与任务栈概述

    任务是指在执行特定作业时与用户交互的一系列 Activity。 这些 Activity 按照各自的打开顺序排列在堆栈(即任务栈)中。

    • 设备主屏幕是大多数任务的起点。当用户触摸应用启动器中的图标(或主屏幕上的快捷方式)时,该应用的任务将出现在前台。 如果应用不存在任务(应用最近未曾使用),则会创建一个新任务,并且该应用的“主”Activity 将作为堆栈中的根 Activity 打开。

    当前 Activity 启动另一个 Activity 时,该新 Activity 会被推送到堆栈顶部,成为焦点所在。 前一个 Activity 仍保留在堆栈中,但是处于停止状态。Activity 停止时,系统会保持其用户界面的当前状态。 用户按“返回”按钮时,当前 Activity 会从堆栈顶部弹出(Activity 被销毁),而前一个 Activity 恢复执行(恢复其 UI 的前一状态)。 堆栈中的 Activity 永远不会重新排列,仅推入和弹出堆栈:由当前 Activity 启动时推入堆栈;用户使用“返回”按钮退出时弹出堆栈。 因此,返回栈以“后进先出”对象结构运行。 下图 通过时间线显示 Activity 之间的进度以及每个时间点的当前返回栈,直观呈现了这种行为。



    作者:cc丶文乐
    链接:https://www.jianshu.com/p/1c7f851608b7#comments
    來源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    2、任务栈关联

    关联指 Activity 优先属于哪个任务。默认情况下,同一应用中的所有 Activity 彼此关联。 因此,默认情况下,同一应用中的所有 Activity 优先位于相同任务中。 不过,可以修改 Activity 的默认关联。 在不同应用中定义的 Activity 可以共享关联,或者可为在同一应用中定义的 Activity 分配不同的任务关联。

    • 可以使用activity元素的 taskAffinity属性修改任何给定 Activity 的关联。

    taskAffinity 属性取字符串值,该值必须不同于在AndroidManifest.xml文件中声明的默认软件包名称,因为系统使用该名称标识应用的默认任务关联。

    在两种情况下,关联会起作用:

    1. 启动 Activity 的 Intent 包含 FLAG_ACTIVITY_NEW_TASK标志。

    2. Activity 将其allowTaskReparenting 属性设置为 true。

      在这种情况下,Activity 可以从其启动的任务移动到与其具有关联的任务(如果该任务出现在前台)。

    3、清理任务栈

    如果用户长时间离开应用,则系统会清除应用下所有除 Activity 的所有 Activity 。 当用户再次返回到任务时,仅恢复根 Activity。系统这样做的原因是,经过很长一段时间后,用户可能已经放弃之前执行的操作,返回到任务是要开始执行新的操作。
    可以使用下列几个 Activity 属性修改此行为:

    • alwaysRetainTaskState
      如果在任务的根 Activity 中将此属性设置为 true`,则不会发生刚才所述的默认行为。即使在很长一段时间后,任务仍将所有 Activity 保留在其堆栈中。

    • clearTaskOnLaunch
      如果在任务的根 Activity 中将此属性设置为 "true",则每当用户离开任务然后返回时,系统都会将堆栈清除到只剩下根 Activity。 换而言之,它与 alwaysRetainTaskState 正好相反。 即使只离开任务片刻时间,用户也始终会返回到任务的初始状态。

    • finishOnTaskLaunch
      此属性类似于 clearTaskOnLaunch,但它对单个 Activity 起作用,而非整个任务。 此外,它还有可能会导致任何 Activity 停止,包括根 Activity。 设置为 true 时,Activity 仍是任务的一部分,但是仅限于当前会话。如果用户离开然后返回任务,则任务将不复存在。


    四、Activity的启动模式

    在AndroidManifest.xml文件中为Activity配置相应的launchMode属性可以设置Activity的启动模式,共如下四种模式:

    • standard
    • singleTask
    • singleTop
    • singleInstance
      接下来对四种启动模式进行详细分析。

    1、standard模式

    标准启动模式:
    该模式下每次启动Activity都会重新创建Activity实例,在这种模式下谁启动了这个Actvitiy,那么这个Activity与被启动的Activity位于启动它的Activity的栈中。

    但是在代码中采用ApplicationContext去开启Activity时(例如执行如下代码时):

    getApplication().startActivity(new Intent(HomeActivity.this,MainActivity.class));
    

    会报如下所示的错误



    作者:cc丶文乐
    链接:https://www.jianshu.com/p/1c7f851608b7#comments
    來源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    • 分析:非Activity类型的Context(如ApplicationContext)并没有任务栈。
    • 解决方案:为待启动的Activity指定FLAG_ACTIVITY_NEW_TASK标记,那么通过这种方式启动的Activity就会新开启一个任务栈。

    2、singleTop模式

    栈顶复用模式:
    该模式下如果Activity已经位于栈顶,那么该Activity不会重新创建,同时它的OnNewIntent方法会被调用,通过方法的参数可以取出其中的信息,并且在这种模式如果这个Actvitiy不位于栈顶,那么这个Activity依然会被重新创建。

    图4.2 OnNewIntent方法

    3、singleTask模式

    栈内复用模式:
    只要Activity实例在一个栈中存在,那么再次启动该Activity时不会重新创建实例,并且系统也会回调其OnNewIntent方法,并且该模式下有清除栈顶实例的效果,即会将与singleTask模式下的该Activity同一个栈中的栈顶的所有Activity实例全部出栈。

    4、singleInstance模式

    单实例模式:
    单实例模式具备singleTask模式的所有的特性,此外具有此模式的Activity只能单独位于一个任务栈中。

    在这里,我们以HomeActivity、MainActivity、DetailActivity三个Activity演示singleInstance模式下的页面跳转,其中MainActivity为singleInstance模式,其他两个页面为standard模式。




    作者:cc丶文乐
    链接:https://www.jianshu.com/p/1c7f851608b7
    來源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处
    展开全文
  • 三分钟明白 Activiti工作流 -- java运用

    万次阅读 多人点赞 2018-11-15 15:10:34
    一、 什么是工作流 以请假为例,现在大多数公司的请假流程是这样的 员工打电话(或网聊)向上级提出请假申请——上级口头同意——上级将请假记录下来——月底将请假记录上交公司——公司将请假录入电脑 ...

     

    一、 什么是工作流

    以请假为例,现在大多数公司的请假流程是这样的

    员工打电话(或网聊)向上级提出请假申请——上级口头同意——上级将请假记录下来——月底将请假记录上交公司——公司将请假录入电脑

    采用工作流技术的公司的请假流程是这样的

    员工使用账户登录系统——点击请假——上级登录系统点击允许

    就这样,一个请假流程就结束了

    有人会问,那上级不用向公司提交请假记录?公司不用将记录录入电脑?答案是,用的。但是这一切的工作都会在上级点击允许后自动运行!

    这就是工作流技术。

     

    Georgakopoulos给出的工作流定义是:工作流是将一组任务组织起来以完成某个经营过程:定义了任务的触发顺序和触发条件,每个任务可以由一个或多个软件系统完成,也可以由一个或一组人完成,还可以由一个或多个人与软件系统协作完

     

    二、 工作流技术的优点

    从上面的例子,很容易看出

    工作流系统,实现了工作流程的自动化,提高了企业运营效率、改善企业资源利用、提高企业运作的灵活性和适应性、提高量化考核业务处理的效率、减少浪费(时间就是金钱)。

    而手工处理工作流程,一方面无法对整个流程状况进行有效跟踪、了解,另一方面难免会出现人为的失误和时间上的延时导致效率低下,特别是无法进行量化统计,不利于查询、报表及绩效评估。

     

    三、 Java开发者会为什么要学Activiti 工作流

    在Java领域,JBPM和Activiti 是两个主流的工作流系统,而Activiti 的出现无疑将会取代JBPM(Activiti 的开发者就是从Jbpm开发者出来的)。

     

    四、 Activiti 工作流学习要点

     

    1. 1个插件

    在Eclipse中安装Activiti 插件,让你可以在Eclipse中绘制Activiti 工作流图

     

    2. 1个引擎

    ProcessEngine对象,Activiti 工作流引擎。这是Activiti工作的核心。负责生成流程运行时的各种实例及数据、监控和管理流程的运行。

    所有的操作都是从获取引擎开始的,所以一般会把引擎作为全局变量

    ProcessEngine processEngine =ProcessEngines.getDefaultProcessEngine();

     

    3. 1个配置文件

    activiti.cfg.xml。Activiti核心配置文件,配置流程引擎创建工具的基本参数和数据库连接池参数

     

    4. 5种数据库表

    Activiti的后台是有数据库的支持,所有的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。

    ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源(图片,规则,等等)。

    ACT_RU_*: 'RU'表示runtime。 这些运行时的表,包含流程实例,任务,变量,异步任务,等运行中的数据。 Activiti只在流程实例执行过程中保存这些数据,在流程结束时就会删除这些记录。 这样运行时表可以一直很小速度很快。

    ACT_ID_*: 'ID'表示identity。 这些表包含身份信息,比如用户,组等等。

    ACT_HI_*: 'HI'表示history。 这些表包含历史数据,比如历史流程实例,变量,任务等等。

    ACT_GE_*: 通用数据,用于不同场景下,如存放资源文件。

     

    5. 23张表

    不同的表存放不同方面的数据,有流程定义表、任务结点表、流程变量表、任务历史表等等。

     

    6. 5项Service

    不同的Service类对应不同的功能。

    比如TaskService,是activiti的任务服务类。可以从这个类中获取任务的信息。

    而HistoryService,则是activiti的查询历史信息的类。在一个流程执行完成后,这个对象为我们提供查询历史信息。

     

    7. 7项基本操作

    设计流程图(各种组件,如连线、用户任务、网关)

    流程定义增删改查

    流程变量增删改查

    启动流程定义

    任务增删改查

    完成任务

    历史信息查询

     

    转自:http://www.it165.net/pro/html/201504/37443.html

    展开全文
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • Activity&Intent详解.pptx

    2020-07-21 09:57:41
    android Activity& android Intent详解, 入门级别
  • Android Intent详解

    2019-06-20 16:16:42
    (一)概念:Intent简单来说就是启动或切换Activity, Service或Broadcast三大组件的。Intent使应用程序代码在运行时动态绑定成为可能,大大降低了不同代码之间的耦合性。Intent最常用的方法是用来启动一个Activity。...
  • Intent详解

    2019-06-15 15:30:35
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • Activity的启动流程简述

    万次阅读 2019-04-21 00:25:06
    Activity 中发起 =====> @Override public void startActivity(Intent intent, @Nullable Bundle options) { if (options != null) { startActivityForResult(intent, -1, options); } else { ...
  • Android之Activity生命周期浅析(一)

    万次阅读 多人点赞 2016-08-03 11:40:15
    Activity作为四大组件之一,出现的频率相当高,基本上我们在android的各个地方都能看见它的踪影,因此深入了解Activity,对于开发高质量应用程序是很有帮助的。今天我们就来详细地聊聊Activity的生命周期,以便我们...
  • Activity

    千次阅读 2020-06-04 09:23:17
    一.生命周期
  • Android之Context和Activity互相转换

    万次阅读 2015-02-03 17:47:06
    1、context转换为activity  Activity activity = (Activity) context; 2、从activity得到context 在activity的方法中用context = getBaseContext(); 而在activity中用context = this即可.
  • Android中获取当前正在显示的Activity

    万次阅读 2018-07-10 11:00:31
    1.监听Activity的生命周期 在Application的onCreate方法中监听Activity的生命周期 registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() { @Override public void onActivityCreated(Act
  • 怎么重启一个activity?我试着像下边这么做,但是activity仍然只是退出。 public static void restartActivity(Activity act){ Intent intent=new Intent(); intent.setClass(act, act.getClass()); ...
  • android启动Activity的两种方法

    万次阅读 2016-08-13 18:16:02
    1. 先说在setClass启动一个Activity的方法吧:(显式调用---直接调用Activity的Class类) Intent intent = new Intent(); intent.setClass(this, CreatePlaylist.class) //参数一为当前Package的context,t当前...
  • Android 清空activity栈的方法

    万次阅读 2015-12-05 11:57:59
    这个标记,将会导致任何用来放置该activity的已经存在的task里面的已经存在的activity先清空,然后该activity再在该task中启动,也就是说,**这个新启动的activity变为了这个空task的根activity.所有老的activity都...
  • 使用adb启动activity

    万次阅读 2015-01-22 16:09:13
    在做Android开发的时候一般情况下我们很少使用adb命令来打开应用,但是有些特殊情况需要使用adb来打开应用的某个activity,并且在打开activity的时候还学要传入一些简单的参数 用来指明要做的业务逻辑,下面开始进入...
  • Android 获取当前Activity实例对象? 在项目开发中,遇到这么个情景,Activity是第三方部门的jar包,而我们需要当前界面用户输入的值 并且校验,jar包里面 并没有提供支持,然而这个jar包牵扯跨部门众多,更新困难...
1 2 3 4 5 ... 20
收藏数 826,691
精华内容 330,676
关键字:

activity