彻底弄懂Activity四大启动模式

图片 52

事情未发生前一贯都以看外人写的起步形式,发掘网络海高校部分的原委都以抄袭来抄袭去,直到眼下看了开采形式那本书,开掘此前对运行方式的掌握过于简短,非常多事物都未曾假造到,为了深化明白,于是决定自个儿入手去印证一下几个运营形式。当然大家也从最简便的运转格局开头验证。

 standard、singleTop、singleTask、singleInstance
       接下来,大家单方面讲理论少年老成边结合案例来周到学习那八种运行情势。
     
 为了打字与印刷方便,定义八个基本功Activity,在其onCreate方法和onNewIntent方法中打字与印刷出脚下Activity的日记音讯,首要包涵所属的task,当前类的hashcode,以致taskAffinity的值。之后大家开展测量试验的Activity都直接接轨该Activity

ctivity的三种运转模式:

为了打字与印刷方便,定义二个根底Activity,在其onCreate方法和onNewIntent方法中打字与印刷出脚下Activity的日记新闻,首要富含所属的task,当前类的hashcode,以至taskAffinity的值。之后大家举办测量检验的Activity都直接接轨该Activity

import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

/**
 * Created by huangshuai on 2016/5/23.
 * Email:huangshuai@wooyun.org
 * 方便打印的基础Activity
 */
public class BaseActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        Log.i("WooYun", "*****onCreate()方法******");
        Log.i("WooYun", "onCreate:" + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
        Log.i("WooYun", "*****onNewIntent()方法*****");
        Log.i("WooYun", "onNewIntent:" + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

protected void dumpTaskAffinity(){
try {
            ActivityInfo info = this.getPackageManager()
                    .getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
            Log.i("WooYun", "taskAffinity:"+info.taskAffinity);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}

standard、singleTop、singleTask、singleInstance

public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.e("TAG", "===========================================onCreate=========================================================");
        Log.e("TAG", "onCreate " + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        Log.e("TAG", "===========================================onNewIntent=========================================================");
        Log.e("TAG", "onNewIntent " + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

    protected void dumpTaskAffinity(){
        try {
            ActivityInfo info = this.getPackageManager()
                    .getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
            Log.e("TAG", "taskAffinity:"+info.taskAffinity);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}

图片 1

为了打字与印刷方便,定义一个幼功Activity,在其onCreate方法和onNewIntent方法中打印出当下Activity的日记新闻,首要不外乎所属的task,当前类的hashcode,甚至taskAffinity的值。之后我们开展测量检验的Activity都一间接轨该Activity

standard模式

style=”text-indent: 24px; background-color: #fdfdfd;”>那些形式是暗中同意的起步方式,即标准情势,在不点名运营情势的前提下,系统暗中同意使用该形式运转Activity,每一回运营三个Activity都会重写创立一个新的实例,不管那些实例存海市蜃楼,这种格局下,哪个人运维了该格局的Activity,该Activity就归于起步它的Activity的任务栈中。

新建贰个Activity,并宣称在manifest文件中

<activity android:name=".standard.StandardActivity"
          android:launchMode="standard"
    >
</activity>

对于standard模式,android:launchMode能够不实行宣示,因为暗中同意正是standard。

StandardActivity
的代码如下,入口Activity中有三个开关步向该Activity,这一个Activity中又有四个开关运营StandardActivity。

public class StandardActivity extends BaseActivity {
    private Button jump;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_standard);

        jump= (Button) findViewById(R.id.jump);
        jump.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(StandardActivity.this, StandardActivity.class);
                startActivity(intent);
            }
        });
    }

}

看下gif动态图,有一些卡顿,凑合看,大家第豆蔻年华步入StandardActivity,步入后再点击**测试Standard**的开关,再按八次再次回到键不断重临。

图片 2

输出的日记如下

图片 3

能够看见日志输出了陆回StandardActivity的和一遍MainActivity的,从MainActivity走入StandardActivity三次,后来大家又按了三回按键,总共八回斯坦dardActivity的日志,何况所属的职分栈的id都以62,那也作证了**哪个人运营了该形式的Activity,该Activity就归属起步它的Activity的天职栈中**那句话,因为运营StandardActivity的是MainActivity,而MainActivity的taskId是62,因而运维的StandardActivity也应有归属id为62的那几个task,后续的3个StandardActivity是被StandardActivity那一个目的运营的,因而也理应依然62,所以taskId都是62。並且每二个Activity的hashcode都是不等同的,表明她们是例外的实例,即**每一回运维二个Activity都会重写创造八个新的实例**

standard-暗许形式

     
 那么些形式是暗中认可的启航航空模型型式,即正式格局,在不点名运维格局的前提下,系统暗中同意使用该方式运转Activity,每回运维多个Activity都会重写创制二个新的实例,不管这几个实例存不设有,这种形式下,哪个人运转了该形式的Activity,该Activity就归于起步它的Activity的职分栈中。这些Activity它的onCreate(卡塔尔国,onStart(卡塔尔,onResume(卡塔尔(قطر‎方法都会被调用。
配置格局:

<activity android:name=".standard.StandardActivity" android:launchMode="standard" > 
  • 1

图片 4

接受案例:
     
 对于standard情势,android:launchMode能够不开展宣示,因为暗中认可正是standard。
       StandardActivity
的代码如下,入口Activity中有多少个开关步向该Activity,这几个Activity中又有二个开关运行StandardActivity。

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email:huangshuai@wooyun.org
 * Standard模式
*/
public class ActivityStandard extends BaseActivity  {
private Buttonjump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_standard);

jump= (Button) findViewById(R.id.btn_standard);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivityStandard.this, ActivityStandard.class);
                startActivity(intent);
            }
        });
    }
}

图片 5

     
 大家率先步入StandardActivity,步向后再点击进入Standard的开关,再按八次重临键不断重回。

图片 6

输出的日志如下:

图片 7

     
 能够看出日志输出了陆遍StandardActivity的和二次MainActivity的,从MainActivity步入StandardActivity三遍,后来大家又按了一回开关,总共六回斯坦dardActivity的日记,况且所属的任务栈的id都以2087,那也表明了什么人运维了该形式的Activity,该Activity就归属起步它的Activity的天职栈中那句话,因为运营StandardActivity的是MainActivity,而MainActivity的taskId是2087,由此运营的StandardActivity也相应归于id为2087的这么些task,后续的3个StandardActivity是被StandardActivity这一个目的运行的,因而也应当照旧2087,所以taskId都以2087。并且每三个Activity的hashcode都以不风流倜傥致的,表达他俩是分化的实例,即“每便运转四个Activity都会重写创造一个新的实例”

import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

public class BaseActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.i("LaunchMode", "*****onCreate()方法******");
        Log.i("LaunchMode", "onCreate:" + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        Log.i("LaunchMode", "*****onNewIntent()方法*****");
        Log.i("LaunchMode", "onNewIntent:" + getClass().getSimpleName() + " TaskId: " + getTaskId() + " hasCode:" + this.hashCode());
        dumpTaskAffinity();
    }

    protected void dumpTaskAffinity() {
        try {
            ActivityInfo info = this.getPackageManager()
                    .getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
            Log.i("LaunchMode", "taskAffinity:" + info.taskAffinity);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }
}

singleTop,栈顶复用方式

其一格局下,纵然新的activity已经放在栈顶,那么那个Activity不会被重写创造,相同的时间它的onNewIntent措施会被调用。倘若栈顶空中楼阁该Activity的实例,则景况与standard形式雷同。

SingleTopActivity代码和StandardActivity形似,只但是记得在manifest文本后中改良运营形式。

<activity android:name=".singletop.SingleTopActivity"
              android:launchMode="singleTop">

操作和standard方式相似,间接贴输出日志

图片 8

咱俩来看,除了第贰遍跻身SingleTopActivity那个Activity时,输出的是onCreate方法中的日志,后续的都以调用了onNewIntent方法,并不曾调用onCreate方法,而且八个日志的hashcode都以均等的,表达栈中独有三个实例。这是因为第叁次跻身的时候,栈中未有该实例,则开创,后续的贰遍发现栈顶有其大器晚成实例,则一向复用,并且调用onNewIntent方法。那么借使栈中有该实例,可是该实例不在栈顶情形又如何呢。

我们先从MainActivity中跻身到SingleTopActivity,然后再跳转到OtherActivity中,再从OtherActivity中跳回SingleTopActivity,再从SingleTopActivity跳到SingleTopActivity中,看看整个进度的日志。

图片 9

大家来看从MainActivity步入到SingleTopActivity时,新建了叁个SingleTopActivity对象,並且task
id与MainActivity是相仿的,然后从SingleTopActivity跳到OtherActivity时,新建了三个OtherActivity,那时候task中设有多个Activity,从栈底到栈顶依次是MainActivity,SingleTopActivity,OtherActivity,那时候假使再跳到SingleTopActivity,尽管栈中已经有SingleTopActivity实例了,可是依然会创设八个新的SingleTopActivity实例,那点从上面的日志的hashCode能够见见,那时栈顶是SingleTopActivity,假诺再跳到SingleTopActivity,就能够复用栈顶的SingleTopActivity,即会调用SingleTopActivity的onNewIntent方法。那就是上述日志的全经过。

对以上内容张开总结

  • standard运营形式是默许的开发银行形式,每便运营多少个Activity都会新建一个实例不管栈中是不是本来就有该Activity的实例。
  • singleTop模式分3种情况
    • 当当前栈中本来就有该Activity的实例何况该实例坐落于栈顶时,不会新建实例,而是复用栈顶的实例,而且会将Intent对象传入,回调onNewIntent方法。
    • 当当前栈中原来就有该Activity的实例但是该实例不在栈顶时,其一言一动和standard运营格局相符,依旧会成立二个新的实例
    • 当当前栈中不设有该Activity的实例时,其行为同standard运营形式。
  • standard和singleTop运维情势都是在原义务栈中新建Activity实例,不会运营新的Task,即时你内定了taskAffinity属性。

那么怎么着是taskAffinity属性呢,能够省略的敞亮为天职相关性。

  • 其豆蔻梢头参数标识了三个Activity所需职分栈的名字,默许情形下,全数Activity所需的职分栈的名为利用的包名。
  • 咱俩得以单独钦定每叁个Activity的taskAffinity属性覆盖暗许值
  • 一个职务的affinity决计于这些职责的根activity(root
    activity)的taskAffinity。
  • 在概念上,具备相符的affinity的activity(即设置了相同taskAffinity属性的activity)归于同一个职责。
  • 为一个activity的taskAffinity设置多少个空字符串,评释这一个activity不归属别的task。

很珍视的一点taskAffinity属性不对standard和singleTop情势有其余影响,即时您钦点了该属性为别的差异的值,那三种运行形式下不会创制新的task

咱俩钦定早前的事例的taskAffinity分别为别的不一样的值,入口Activity不钦命(不点名即私下认可值,即包名)

<activity android:name=".standard.StandardActivity"
          android:launchMode="standard"
          android:taskAffinity="cn.edu.zafu.lifecycle.standard"
    >
</activity>

<activity android:name=".singletop.SingleTopActivity"
          android:launchMode="singleTop"
          android:taskAffinity="cn.edu.zafu.lifecycle.singletop"
    >
</activity>

分级运行那八个Activity看日志输出

图片 10

大家见到入口Activity的taskAffinity值正是包名,正是私下认可意况下不钦点的。然后斯坦dardActivity和SingleTopActivity的taskAffinity值被大家覆盖了,分别为差别的值,可是那七个Activity运营的时候职务栈并未有新建,而是直接在原来的Task中运行,这证明那个taskAffinity对这二种运行情势还未有怎么影响。其实该属性重假使拾叁分SingleTask运行情势应用的。接下来大家看该运转情势,能够说这么些运维情势是最复杂的。

singleTop-栈顶复用方式

     
 那一个形式下,借使新的activity已经坐落于栈顶,那么那些Activity不会被重写创造,同不经常间它的onNewIntent方法会被调用,通过此措施的参数我们能够去除当前恳请的音讯。假使栈顶空头支票该Activity的实例,则情形与standard方式雷同。须要在乎的是其一Activity它的onCreate(卡塔尔,onStart(卡塔尔方法不会被调用,因为它并未发生退换。
配备方式:

<activity android:name=".singletop.SingleTopActivity" android:launchMode="singleTop">
  • 1

图片 11

选用案例:
ActivitySingleTop.java

/**
 * Created by huangshuai on 2016/5/23.
 * Email:huangshuai@wooyun.org
 * SingleTop模式
*/
public class ActivitySingleTop extends BaseActivity {
private Button jump,jump2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_singletop);

jump = (Button) findViewById(R.id.btn_singletop);
jump2 = (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTop.this, ActivitySingleTop.class);
                startActivity(intent);
            }
        });
jump2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTop.this, OtherTopActivity.class);
                startActivity(intent);
            }
        });

图片 12

OtherTopActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email:huangshuai@wooyun.org
 */
public class OtherTopActivity extends BaseActivity {
private Button jump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_other);

jump= (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(OtherTopActivity.this, ActivitySingleTop.class);
                startActivity(intent);
            }
        });
    }
}

图片 13

操作和standard情势雷同,间接贴输出日志

图片 14

     
 大家看看,除了第二回跻身SingleTopActivity那个Activity时,输出的是onCreate方法中的日志,后续的都是调用了onNewIntent方法,并从未调用onCreate方法,何况多个日志的hashcode都以千篇意气风发律的,表达栈中唯有多个实例。那是因为第一次跻身的时候,栈中未有该实例,则开创,后续的一遍开采栈顶有其一实例,则一贯复用,而且调用onNewIntent方法。那么假如栈中有该实例,可是该实例不在栈顶意况又怎么呢?
     
 大家先从MainActivity中跻身到SingleTopActivity,然后再跳转到OtherActivity中,再从OtherActivity中跳回SingleTopActivity,再从SingleTopActivity跳到SingleTopActivity中,看看整个过程的日志。

图片 15

图片 16

图片 17

     
 大家看看从MainActivity步向到SingleTopActivity时,新建了三个SingleTopActivity对象,並且task
id与MainActivity是相似的,然后从SingleTopActivity跳到OtherActivity时,新建了三个OtherActivity,那时task中存在四个Activity,从栈底到栈顶依次是MainActivity,SingleTopActivity,OtherActivity,这时候只要再跳到SingleTopActivity,纵然栈中已经有SingleTopActivity实例了,不过依然会成立一个新的SingleTopActivity实例,那点从下面的日志的hashCode能够观察,那时候栈顶是SingleTopActivity,假诺再跳到SingleTopActivity,就能复用栈顶的SingleTopActivity,即会调用SingleTopActivity的onNewIntent方法。那就是上述日志的全经过。
对上述内容实行总计
     
 standard运营形式是默许的运行情势,每一趟运行四个Activity都会新建二个实例不管栈中是还是不是原来就有该Activity的实例。
singleTop模式分3种情况

  1. 一时栈中本来就有该Activity的实例并且该实例坐落于栈顶时,不会新建实例,而是复用栈顶的实例,何况会将Intent对象传入,回调onNewIntent方法
  2. 脚下栈中原来就有该Activity的实例但是该实例不在栈顶时,其表现和standard运转情势相像,依旧会创设叁个新的实例
  3. 当前栈中不设有该Activity的实例时,其表现同standard运营方式

     
 standard和singleTop运行情势都以在原职务栈中新建Activity实例,不会运转新的Task,固然你钦命了taskAffinity属性。
那么如何是taskAffinity属性呢,能够简轻便单的通晓为职分相关性。

  • 其意气风发参数标志了八个Activity所需任务栈的名字,暗中同意意况下,全部Activity所需的任务栈的名叫使用的包名
  • 咱俩得以独自钦赐每四个Activity的taskAffinity属性覆盖暗中认可值
  • 三个任务的affinity决计于这些职分的根activity(root
    activity)的taskAffinity
  • 在概念上,具备相近的affinity的activity(即设置了扳平taskAffinity属性的activity)归于同二个任务
  • 为一个activity的taskAffinity设置一个空字符串,注解这些activity不属于别的task

     
 很关键的一点taskAffinity属性不对standard和singleTop格局有别的影响,即时你钦赐了该属性为其它分裂的值,那二种运维格局下不会创建新的task(假设不钦点即私下认可值,即包名)
钦点方式如下:

<activity android:name=".ActivitySingleTop" android:launchMode="singleTop" android:taskAffinity="com.castiel.demo.singletop"/>
  • 1

图片 18

<activity android:name=".ActivityStandard" android:launchMode="standard" android:taskAffinity="com.castiel.demo.standard"/>
  • 1

图片 19

风度翩翩、standard——规范情势(暗中同意形式)

singleTask,即栈内复用方式

以此方式十一分复杂,有丰富多采的组合。在这里个格局下,要是栈中设有那几个Activity的实例就能复用那么些Activity,不管它是不是坐落于栈顶,复用时,会将它上边的Activity全体出栈,而且会回调该实例的onNewIntent方法。其实那一个进程还留存三个职务栈的合作,因为这么些格局运营时,会在本身索要的职分栈中搜索实例,这么些职务栈就是通过taskAffinity属性钦定。
若果那个义务栈不设有,则会创设这几个任务栈。

指定Activity为singleTask模式

<activity android:name=".singleTask.SingleTaskActivity"
          android:launchMode="singleTask"
    >
</activity>

昨日大家不点名其余taskAffinity属性,对它做相似singleTop的操作,即从入口MainActivity进入SingleTaskActivity,然后跳到OtherActivity,再跳回到SingleTaskActivity。看看整个经过的日记。

图片 20

当大家从MainActiviyty走入到SingleTaskActivity,再步入到OtherActivity后,那个时候栈中有3个Activity实例,况且SingleTaskActivity不在栈顶,而在OtherActivity跳到SingleTaskActivity时,并未开创三个新的SingleTaskActivity,而是复用了该实例,而且回调了onNewIntent方法。並且原本的OtherActivity出栈了,具体见下边包车型客车音讯,使用命令adb
shell dumpsys activity activities
可进展查看

Running activities (most recent first):
TaskRecord{434c6d90 #77 A=cn.edu.zafu.lifecycle U=0 sz=2}
Run #2: ActivityRecord{4358c850 u0
cn.edu.zafu.lifecycle/.singleTask.SingleTaskActivity t77}
Run #1: ActivityRecord{43576720 u0
cn.edu.zafu.lifecycle/.MainActivity t77}

能够看到日前栈中唯有三个Activity,即原本栈中坐落于SingleTaskActivity
之上的Activity都出栈了。

咱俩看见选取singleTask运维情势运行三个Activity,它依旧在本来的task中运维。其实是这么的,大家并没有一些名taskAffinity属性,那表明和暗许值相仿,约等于包名,当MainActivity运营时创建的Task的名字正是包名,因为MainActivity也从没点名taskAffinity,而当大家运营SingleTaskActivity
,首先会招来必要的任务栈是或不是留存,也等于taskAffinity钦赐的值,这里就是包名,发现成在,就不再次创下设新的task,而是平素接受。当该task中存在该Activity实例时就能复用该实例,那正是栈内复用格局。

那儿,假如我们钦定SingleTaskActivity 的taskAffinity值。

<activity android:name=".singleTask.SingleTaskActivity"
          android:launchMode="singleTask"
          android:taskAffinity="cn.edu.zafu.lifecycle.singleTask"
    >
</activity>

依旧前边的操作。不过日志就能变得不相通。

图片 21

咱俩看出SingleTaskActivity所属的任务栈的TaskId爆发了转移,也正是说开启了二个新的Task,况且之后的OtherActivity也运维在了该Task上

打字与印刷出音信也表明了存在三个不相同的Task

Running activities (most recent first):
TaskRecord{441ab678 #79 A=cn.edu.zafu.lifecycle.singleTask U=0
sz=1}
Run #3: ActivityRecord{432fa178 u0
cn.edu.zafu.lifecycle/.singleTask.SingleTaskActivity t79}
TaskRecord{43ccd2a8 #78 A=cn.edu.zafu.lifecycle U=0 sz=1}
Run #2: ActivityRecord{42d5e7a8 u0
cn.edu.zafu.lifecycle/.MainActivity t78}

借使咱们钦点MainActivity的taskAffinity属性和SingleTaskActivity相仿,又会并发什么样情况吧。

图片 22

没有错,正是和他们如何都不点名是相似的。

此刻,就有了上边包车型客车定论

  • singleTask运营方式运行Activity时,首先会基于taskAffinity去寻觅当前是或不是留存二个应和名字的职分栈
    • 万一不设有,则会创建叁个新的Task,并创办新的Activity实例入栈到新成立的Task中去
    • 假诺存在,则收获该职责栈,查找该任务栈中是不是存在该Activity实例
      • 纵然存在实例,则将它上边的Activity实例都出栈,然后回调运维的Activity实例的onNewIntent方法
      • 比如不真实该实例,则新建Activity,并入栈

其它,大家能够将四个例外App中的Activity设置为相符的taskAffinity,那样即使在分歧的应用中,可是Activity会被分配到同两个Task中去

小编们再成立其余三个使用,钦定它的taskAffinity和前边的同等,都以cn.edu.zafu.lifecycle.singleTask

<activity android:name=".OtherActivity"
                  android:launchMode="singleTask"
                  android:taskAffinity="cn.edu.zafu.lifecycle.singleTask"
            >
        </activity>

然后运维七个行使,让她跳转到该Activity后,再按home键后台,运行另一个接受再步入该Activity,看日志

图片 23

小编们见到,钦定了风流洒脱致的taskAffinity的SingleTaskActivity和OtherActivity被运维到了同一个task中,taskId都为274。

singleTask-栈内复用格局

     
 这些格局十二分复杂,有五光十色标整合。在这里个方式下,如果栈中留存那么些Activity的实例就能复用那几个Activity,不管它是不是坐落于栈顶,复用时,会将它上边的Activity全体出栈,而且会回调该实例的onNewIntent方法。其实这么些进度还存在贰个职分栈的合营,因为这些形式运营时,会在投机须要的职责栈中搜索实例,这么些职分栈正是通过taskAffinity属性钦定。假设那几个职务栈不设有,则会创制那几个职务栈。
配备方式:

<activity android:name=".singleTask.SingleTaskActivity" android:launchMode="singleTask" >
  • 1

图片 24

使用案例:
ActivitySingleTask.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email:huangshuai@wooyun.org
 * SingleTask模式
*/
public class ActivitySingleTask extends BaseActivity {
private Button jump,jump2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_task);

jump = (Button) findViewById(R.id.btn_task);
jump2 = (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTask.this, ActivitySingleTask.class);
startActivity(intent);
            }
        });
jump2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(ActivitySingleTask.this, OtherTaskActivity.class);
startActivity(intent);
            }
        });
    }
}

图片 25

OtherTaskActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

/**
 * Created by huangshuai on 2016/5/23.
 * Email:huangshuai@wooyun.org
 */
public class OtherTaskActivity extends BaseActivity {
private Button jump;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_other_task);

jump= (Button) findViewById(R.id.btn_other);
jump.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
                Intent intent = new Intent(OtherTaskActivity.this, ActivitySingleTask.class);
                startActivity(intent);
            }
        });
    }
}

图片 26

     
 今后大家先不钦赐别的taskAffinity属性,对它做相像singleTop的操作,即从入口MainActivity踏入SingleTaskActivity,然后跳到OtherActivity,再跳回到SingleTaskActivity。看看整个进程的日志。

图片 27

图片 28

图片 29

图片 30

     
 当大家从MainActiviyty步向到SingleTaskActivity,再进来到OtherActivity后,那个时候栈中有3个Activity实例,况兼SingleTaskActivity不在栈顶,而在OtherActivity跳到SingleTaskActivity时,并未有开创二个新的SingleTaskActivity,而是复用了该实例,並且回调了onNewIntent方法。並且原本的OtherActivity出栈了,具体见下面包车型地铁消息,使用命令adb
shell dumpsys activity activities
可进展查看

图片 31

     
 能够看出日前栈中唯有三个Activity,即原来栈中坐落于SingleTaskActivity
之上的Activity都出栈了。
     
 大家看来使用singleTask运维形式运营多少个Activity,它依旧在原来的task中运营。其实是那般的,大家并不曾点名taskAffinity属性,那注明和默许值同样,也便是包名,当MainActivity运转时创立的Task的名字就是包名,因为MainActivity也从没点名taskAffinity,而当大家运行SingleTaskActivity
,首先会寻觅供给的职分栈是或不是存在,也正是taskAffinity钦定的值,这里正是包名,开掘成在,就不更创制新的task,而是直接运用。当该task中留存该Activity实例时就可以复用该实例,那正是栈内复用方式。
       此时,要是我们内定SingleTaskActivity 的taskAffinity值。

<activity android:name=".ActivitySingleTask" android:launchMode="singleTask" android:taskAffinity="com.castiel.demo.singletask"/>
  • 1

图片 32

要么事情发生前的操作。可是日志就能够变得不相似。

图片 33

     
 我们见到SingleTaskActivity所属的职务栈的TaskId产生了退换,也正是说开启了三个新的Task,何况之后的OtherActivity也运行在了该Task上
打字与印刷出音讯也认证了存在多个不等的Task

图片 34

假若大家钦点MainActivity的taskAffinity属性和SingleTaskActivity同样,又会并发什么样动静吧。

图片 35

对的,便是和他们怎么样都不点名是相似的。
此刻,就有了下边包车型地铁定论
singleTask运维方式运维Activity时,首先会基于taskAffinity去搜索当前是或不是留存一个应和名字的职务栈

  • 假诺不设有,则会创建叁个新的Task,并创办新的Activity实例入栈到新成立的Task中去
  • 若果存在,则收获该任务栈,查找该职分栈中是或不是存在该Activity实例
                
     假若存在实例,则将它上边的Activity实例都出栈,然后回调运转的Activity实例的onNewIntent方法
                  假设官样文章该实例,则新建Activity,并入栈
    其余,我们得以将四个例外App中的Activity设置为相近的taskAffinity,这样即使在差异的应用中,可是Activity会被分配到同一个Task中去。
    俺们再次创下设其它二个行使,内定它的taskAffinity和前面包车型大巴同等,都以com.xingyu.demo.singletask

<activity android:name=".MainActivity" android:launchMode="singleTask" android:taskAffinity="com.castiel.demo.singletask"/>
  • 1

图片 36

然后运营四个接纳,让她跳转到该Activity后,再按home键后台,运营另一个运用再步向该Activity,看日志

图片 37

     
 我们见到,钦赐了相像的taskAffinity的SingleTaskActivity和OtherActivity被运转到了同一个task中,taskId都为2169。

  那个形式是默许的开行格局,即正式情势,在不钦点运营格局的前提下,系统暗中认可使用该形式运营Activity,每一趟运行三个Activity都会重写创设贰个新的实例,不管这一个实例存不设有,这种格局下,何人运行了该格局的Activity,该Activity就归于起步它的Activity的职责栈中。那个Activity它的onCreate(卡塔尔,onStart(State of Qatar,onResume(卡塔尔方法都会被调用。

singleInstance模式

该方式抱有singleTask方式的有着本性外,与它的分别正是,这种方式下的Activity会单独占用贰个Task栈,具有全局唯朝气蓬勃性,即一切系统中就这么贰个实例。以singleInstance格局运维的Activity在一切系统中是单例的,如果在开发银行那样的Activiyt时,已经存在了一个实例,那么会把它所在的任务调解到前台,重用那个实例。

追加三个Activity,证明如下

<activity android:name=".singleinstance.SingleInstanceActivity"
                  android:launchMode="singleInstance"
            >
            <intent-filter>
                <action android:name="cn.edu.zafu.lifecycle"/>
                <category android:name="android.intent.category.DEFAULT"/>
            </intent-filter>
        </activity>

行使上面包车型客车方法分别在多个利用中运行它

Intent intent = new Intent();
intent.setAction("cn.edu.zafu.lifecycle");
startActivity(intent);

做的操作和上一回是豆蔻年华致的,查看日志

图片 38

咱俩看看,第一个使用运维SingleInstanceActivity时,由于系统中不设有该实例,所以新建了三个Task,按home键后,使用另二个App步入该Activity,由于系统中已经存在了贰个实例,不会再成立新的Task,直接复用该实例,并且回调onNewIntent方法。能够从他们的hashcode中得以见到那是同八个实例。

对上述内容的总计便是

SingleInstance形式运营的Activity在系统中存有全局唯生龙活虎性。

singleInstance-全局独一方式

     
 该方式抱有singleTask方式的全体天性外,与它的界别就是,这种形式下的Activity会单独自据有用二个Task栈,具备全局唯风流倜傥性,即全部体系中就那样一个实例,由于栈内复用的性状,后续的央求均不会创设新的Activity实例,除非那么些极度的职务栈被销毁了。以singleInstance情势运转的Activity在方方面面种类中是单例的,倘使在运转那样的Activiyt时,已经存在了三个实例,那么会把它所在的职分调治到前台,重用那个实例。
布局情势:

<activity android:name=".singleinstance.SingleInstanceActivity" android:launchMode="singleInstance" >
  • 1

图片 39

行使案例:
追加二个Activity如下:
ActivitySingleInstance.java

import android.os.Bundle;

/**
 * Created by huangshuai on 2016/5/24.
 * Email:huangshuai@wooyun.org
 * SingleInstance模式
 */
public class ActivitySingleInstance extends BaseActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_singleinstance);
    }
}
配置属性如下:
<activity
    android:name=".ActivitySingleInstance"
    android:launchMode="singleInstance">

    <intent-filter>
        <action android:name="com.castiel.demo.singleinstance" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

图片 40

应用下边包车型大巴秘技分别在八个利用中运营它

Intent intent = new Intent();
intent.setAction("com.castiel.demo.singleinstance");
startActivity(intent);
  • 1
  • 2
  • 3

图片 41

做的操作和上一遍是豆蔻梢头致的,查看日志

图片 42

     
 大家看到,第三个使用运行SingleInstanceActivity时,由于系统中不设有该实例,所以新建了二个Task,按home键后,使用另三个App踏入该Activity,由于系统中已经存在了三个实例,不会再成立新的Task,直接复用该实例,而且回调onNewIntent方法。能够从她们的hashcode中得以见到那是同一个实例。因而我们得以知道为:SingleInstance情势运维的Activity在系统中装有全局唯意气风发性。

参谋链接:

配备方式:

<activity
            android:name=".StandardActivity"
            android:launchMode="standard" />

动用案例:

  StandardActivity.java

  对于standard格局,android:launchMode能够不进行宣示,因为暗许正是standard。 
  StandardActivity
的代码如下,入口Activity中有叁个按键走入该Activity,这一个Activity中又有一个开关运维StandardActivity。

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import butterknife.ButterKnife;
import butterknife.InjectView;

public class StandardActivity extends BaseActivity {

    @InjectView(R.id.button5)
    Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_standard);
        ButterKnife.inject(this);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(StandardActivity.this, StandardActivity.class));
            }
        });
    }
}

  步向StandardActivity,然后再点击贰遍“运营本人”开关,再按八遍重回键再次回到。

图片 43

出口的日志如下:

图片 44

能够看看日志输出了伍遍斯坦dardActivity的和叁次MainActivity的,从MainActivity步入StandardActivity一遍,后来大家又按了二遍开关,总共伍次StandardActivity的日记,何况所属的任务栈的id都以16804,那也印证了何人运维了该形式的Activity,该Activity就归于起步它的Activity的职务栈中那句话,因为运行StandardActivity的是MainActivity,而MainActivity的taskId是16804,由此运维的StandardActivity也应有归于id为16804的这一个task,后续的3个StandardActivity是被斯坦dardActivity那几个目的运转的,由此也理应依然16804,所以taskId都是16804。何况每八个Activity的hashcode都以不风姿罗曼蒂克致的,表达他们是不相同的实例,即“每趟运营一个Activity都会重写创立三个新的实例”。

二、singleTop——Task栈顶单例格局(栈顶复用形式)

  此格局下,假若新的activity已经身处栈顶,那么那个activity不会被另行创制,同不时间他的onNewIntent方法会被调用,此时那一个activity的onCreate(State of Qatar,onStart(State of Qatar方法未有被调用,所以那个activity没有发出变动,照旧同一个activity。通过此格局的参数大家得以取妥帖前乞求的音讯。假若栈顶不设有该activity的实例,则情形与standard格局形似。

安排情势:

<activity
            android:name=".SingleTopActivity"
            android:launchMode="singleTop"
            android:taskAffinity="com.lyf.test.singleTop" />

使用案例:

 SingleTopActivity.java

 

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import butterknife.ButterKnife;
import butterknife.InjectView;

public class SingleTopActivity extends BaseActivity {

    @InjectView(R.id.button6)
    Button button;

    @InjectView(R.id.button10)
    Button button10;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_single_top);
        ButterKnife.inject(this);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(SingleTopActivity.this, SingleTopActivity.class));
            }
        });
        button10.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(SingleTopActivity.this, OtherTopActivity.class));
            }
        });
    }
}

OtherTopActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import butterknife.ButterKnife;
import butterknife.InjectView;

public class OtherTopActivity extends BaseActivity {

    @InjectView(R.id.button9)
    Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_other_top);
        ButterKnife.inject(this);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(OtherTopActivity.this, SingleTopActivity.class));
            }
        });
    }
}

图片 45

 

1、和standard运行方式相近,先运行SingleTopActivity,然后点击叁回“运转自个儿”按键

  输出日志如下:

图片 46

从日记能够观察,除了第一次跻身SingleTopActivity那几个Activity时,输出的是onCreate方法中的日志,后续的都以调用了onNewIntent方法,并未有调用onCreate方法,并且八个日志的hashcode没什么不同的,表明栈中唯有一个实例。那是因为第一次跻身的时候,栈中未有该实例,则开创,后续的三遍开掘栈顶有其生机勃勃实例,则一向复用,何况调用onNewIntent方法。

那正是说即便栈中有该实例,不过该实例不在栈顶处境又怎么呢?

我们先从MainActivity步入到SingleTopActivity,然后点击“运营别的两个activity”运营OtherTopActivity,再从OtherTopActivity调回SingleTopActivity,再从SingleTopActivity跳到SingleTopActivity。日志如下:

图片 47

咱俩见到从MainActivity步向到SingleTopActivity时,新建了三个SingleTopActivity对象,而且task
id与MainActivity是生龙活虎致的,然后从SingleTopActivity跳到OtherActivity时,新建了一个OtherActivity,那时候task中留存八个Activity,从栈底到栈顶依次是MainActivity,SingleTopActivity,OtherActivity,当时风姿罗曼蒂克旦再跳到SingleTopActivity,尽管栈中已经有SingleTopActivity实例了,不过依然会创建一个新的SingleTopActivity实例,这点从上边的日志的hashCode能够看来,这时候栈顶是SingleTopActivity,假设再跳到SingleTopActivity,就可以复用栈顶的SingleTopActivity,即会调用SingleTopActivity的onNewIntent方法。这便是上述日志的全经过。 

 

对以上内容张开计算 
     
 standard运转形式是暗中认可的启航航空模型型式,每一次运营三个Activity都会新建二个实例不管栈中是或不是原来就有该Activity的实例。 
singleTop模式分3种情况

  1. 眼下栈中本来就有该Activity的实例并且该实例坐落于栈顶时,不会新建实例,而是复用栈顶的实例,而且会将Intent对象传入,回调onNewIntent方法
  2. 目前栈中本来就有该Activity的实例可是该实例不在栈顶时,其行事和standard运维形式相通,依旧会创设三个新的实例
  3. 一时一刻栈中不设有该Activity的实例时,其展现同standard运维格局

 standard和singleTop运营格局都以在原职分栈中新建Activity实例,不会运转新的Task,即便你钦定了taskAffinity属性。

那么如何是taskAffinity属性呢,能够简轻易单的领会为任务相关性。

  • 其大器晚成参数标志了二个Activity所需职务栈的名字,暗中同意意况下,全体Activity所需的任务栈的名叫运用的包名
  • 我们能够独自钦命每三个Activity的taskAffinity属性覆盖暗中同意值
  • 五个职分的affinity决议于这些义务的根activity(root
    activity)的taskAffinity
  • 在概念上,具有相像的affinity的activity(即设置了相像taskAffinity属性的activity)归属同四个任务
  • 为叁个activity的taskAffinity设置三个空字符串,阐明这些activity不归于其余task

     
 很主要的一点taskAffinity属性不对standard和singleTop方式有此外影响,即时你钦命了该属性为任何差别的值,这两种运营格局下不会创立新的task(若是不钦定即默许值,即包名)

 内定方式如下:

<activity
    android:name=".SingleTopActivity"
    android:launchMode="singleTop"
    android:taskAffinity="com.lyf.test.singleTop" />

三、singleTask——Task栈内单例形式(栈内复用方式)

以此格局拾壹分复杂,有五颜六色的整合。在这里个情势下,若是栈中留存这些Activity的实例就能够复用那么些Activity,不管它是否坐落于栈顶,复用时,会将它下面包车型客车Activity全部出栈,何况会回调该实例的onNewIntent方法。其实这一个进程还存在叁个义务栈的合营,因为那么些形式运维时,会在大团结索要的职分栈中寻觅实例,这一个任务栈正是通过taskAffinity属性钦定。借使这么些任务栈不设有,则会创制那么些职分栈。 

布局情势:

<activity
    android:name=".SingleTaskActivity"
    android:launchMode="singleTask" />

应用案例:

SingleTaskActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import butterknife.ButterKnife;
import butterknife.InjectView;

public class SingleTaskActivity extends BaseActivity {

    @InjectView(R.id.button7)
    Button button;

    @InjectView(R.id.button12)
    Button button12;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_single_task);
        ButterKnife.inject(this);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(SingleTaskActivity.this, SingleTaskActivity.class));
            }
        });
        button12.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(SingleTaskActivity.this, OtherTaskActivity.class));
            }
        });
    }
}

OtherTaskActivity.java

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import butterknife.ButterKnife;
import butterknife.InjectView;

public class OtherTaskActivity extends BaseActivity {

    @InjectView(R.id.button11)
    Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_other_task);
        ButterKnife.inject(this);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(OtherTaskActivity.this, SingleTaskActivity.class));
            }
        });
    }
}

近年来我们先不钦赐其余taskAffinity属性,对它做相像singleTop的操作,即从入口MainActivity步向SingleTaskActivity,然后跳到OtherTaskActivity,再跳回到SingleTaskActivity,然后再开发银行壹遍SingleTaskActivity。看看整个经过的日记。

图片 48

当大家从MainActiviyty步入到SingleTaskActivity,再步入到OtherTaskActivity后,当时栈中有3个Activity实例,况兼SingleTaskActivity不在栈顶,而在OtherTaskActivity跳到SingleTaskActivity时,并未创立二个新的SingleTaskActivity,而是复用了该实例,而且回调了onNewIntent方法。並且原本的OtherTaskActivity出栈了,具体见上面的信息,使用命令adb
shell dumpsys activity activities
可进展查看

Run #2: ActivityRecord{3d8fd26 u0
com.lyf.test.launchmodedemo/.SingleTaskActivity t16826}
Run #1: ActivityRecord{a5ce4 u0
com.lyf.test.launchmodedemo/.MainActivity t16826}

  能够看见日前栈中唯有五个Activity,即原本栈中坐落于SingleTaskActivity
之上的Activity都出栈了。 
     
 我们见到使用singleTask运维格局运维三个Activity,它还是在原来的task中运维。其实是那般的,我们并未点名taskAffinity属性,那注明和暗中同意值近似,也便是包名,当MainActivity运转时创造的Task的名字便是包名,因为MainActivity也未尝点名taskAffinity,而当大家运转SingleTaskActivity
,首先会寻觅需求的职责栈是还是不是留存,也正是taskAffinity钦命的值,这里正是包名,发现有在,就不再次创下设新的task,而是直接使用。当该task中留存该Activity实例时就能复用该实例,那便是栈内复用格局。  

  当时,假诺我们钦点SingleTaskActivity 的taskAffinity值。

<activity
    android:name=".SingleTaskActivity"
    android:launchMode="singleTask"
    android:taskAffinity="com.lyf.test.singleTask" />

这时候,如果我们指定SingleTaskActivity 的taskAffinity值。

图片 49

我们来看SingleTaskActivity所属的天职栈的TaskId发生了退换,也正是说开启了一个新的Task,并且之后的OtherActivity也运维在了该Task上 
打字与印刷出消息也印证了设有五个例外的Task

TaskRecord{e8e7b96 #16829 A=com.lyf.test.singleTask U=0 sz=1}
Run #2: ActivityRecord{2408723 u0
com.lyf.test.launchmodedemo/.SingleTaskActivity t16829}
TaskRecord{e451852 #16828 A=com.lyf.test.launchmodedemo U=0 sz=1}
Run #1: ActivityRecord{e6a1ffb u0
com.lyf.test.launchmodedemo/.MainActivity t16828}

 借使我们内定SingleTaskActivity的taskAffinity属性与MainActivity相近,有会现出哪些状态呢?

配备情势:

<activity
    android:name=".SingleTaskActivity"
    android:launchMode="singleTask"
    android:taskAffinity="com.lyf.test.launchmodedemo" />

日志如下:

图片 50

科学,便是和他们什么都不点名是如出意气风发辙的。 
那时,就有了上面包车型地铁下结论 
singleTask运行格局运营Activity时,首先会依据taskAffinity去搜寻当前是或不是留存一个一呼百应名字的天职栈

  • 生机勃勃经不设有,则会创制三个新的Task,并创建新的Activity实例入栈到新创制的Task中去
  • 设若存在,则获得该职责栈,查找该义务栈中是还是不是留存该Activity实例 
           
    假诺存在实例,则将它上面包车型客车Activity实例都出栈,然后回调运维的Activity实例的onNewIntent方法 
            假若子虚乌有该实例,则新建Activity,并入栈 
    别的,大家得以将三个不等App中的Activity设置为同风华正茂的taskAffinity,那样就算在差别的施用中,可是Activity会被分配到同二个Task中去。 
    大家再创设其余叁个使用,内定它的taskAffinity和前边的同等,都是com.lyf.test.singleTask

<activity
    android:name=".OtherActivityActivity"
    android:launchMode="singleTask"
    android:taskAffinity="com.lyf.test.singleTask"></activity>

专一:新利用的activity也应设置为singleTask格局。不然效果是不雷同的。

先运行二个利用,让他跳转到该Activity后,再按home键让该行使在后台运转,然后运转另三个运用再步入站内单例Activity,看日志

图片 51

我们见到,内定了同等的taskAffinity的SingleTaskActivity和OtherActivityActivity被运转到了同多个task中,taskId都为16913。

 四、singleInstance——全局单例方式

 该方式抱有singleTask格局的全体天性,但与它的分别是:这种方式下的Activity会单独自据有用一个Task栈,具备全局唯风流罗曼蒂克性,即全数体系中宛如此叁个实例,由于栈内复用的性状,后续的伏乞均不会创建新的Activity实例,除非这几个特别的职务栈被灭绝了。以singleInstance方式运行的Activity在方方面面系统中是单例的,如果在运营那样的Activiyt时,已经存在了二个实例,那么会把它所在的职分调治到前台,重用这一个实例。 

 配置格局:

<activity
    android:name=".SingleInstanceActivity"
    android:launchMode="singleInstance">
    <intent-filter>
        <action android:name="com.lyf.test.singleinstancedemo" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

行使案例:

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import butterknife.ButterKnife;
import butterknife.InjectView;

public class SingleInstanceActivity extends BaseActivity {

    @InjectView(R.id.button8)
    Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_single_instance);
        ButterKnife.inject(this);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent singleInstanceIntent = new Intent();
                singleInstanceIntent.setAction("com.lyf.test.singleinstancedemo");
                startActivity(singleInstanceIntent);
            }
        });
    }
}

接受上面包车型地铁艺术分别在三个使用中运维它

Intent singleInstanceIntent = new Intent();
singleInstanceIntent.setAction("com.lyf.test.singleinstancedemo");
startActivity(singleInstanceIntent);

操作和上叁个(使用五个app操作)同样,日志如下:

图片 52

小编们看看,第二个利用运转SingleInstanceActivity时,由于系统中空中楼阁该实例,所以新建了一个Task,按home键后,使用另三个App步入该Activity,由于系统中已经存在了三个实例,不会再次创下立新的Task,直接复用该实例,何况回调onNewIntent方法。能够从她们的hashcode中能够观看那是同三个实例。因而我们得以通晓为:SingleInstance形式运营的Activity在系统中具备全局唯意气风发性。

 

git源码:

 

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图