AndroidActivity类在Android操作系统的应用中是常重要的。那么如何才能正确的在应用中来操作这一类呢？在一个应用中，每一个显示的屏幕都是一个Activity。所以学习Android，必须要对Activity有一定的了解。在其他论坛中也有一些关于Activity的介绍，我在这里就想谈谈我对Activity学习的一些看法。首先Activity的生命周期很重要，Activity主要包含六个方法，分别是onCreate，onStart，onResume，onPause，onStop，onDestory。

onCreate和onDestory对应。onStart和onStop对应，onResume和onPause对应。

这几个函数大概是这样定义的，当启动一个Android Activity类的时候，onCreate方法首先会被启动，然后接着是onStart和onResume，也会启动，一般地，等这几个函数都启动完了之后你这个Activity就可以被显示出来了。当然我这里说的是一般的情况，如果你要是在这三个函数初始化的时候启动了一个后台的Service，那么还要等待ServiceConnection执行完毕才能够被显示出来，这里可能有人要问什么是Service了，在以后我会介绍它，这里大家就先了解下Service的回调函数也会影响Acitivity的启动就可以了。

这是Activity启动时会调用的三个函数，在Acitivity销毁的时候会调用onPause，onStop，onDestory。当调用完onDestory之后，你的Acitivity也就被销毁完毕了，这时候你在调用Activity的isFinishing的时候，就会返回true，但是此时Activity的this指针还可以被使用，如果你在Activity单起一个线程做其他事情的话，那么上下文变量context指针还是能够被使用的。

当然Android Activity类有可能还处于其他状态，不一定就是被显示或者被销毁，很有可能这个Activity启动了另一个Activity，这个时候前先的那个Activiy就会被放到系统的堆栈中，等被启动的Activity返回的时候，它又重新被显示出来，这个流程是这样的，一个Activity启动了另外的一个Activity，那么它就会调用onPause函数，进入一种停滞的状态，然后被启动的Activity被销毁返回后，又会调用onResume函数。

对于Activity的这种机制，我感觉在初始化的工作最好放到一个自己定义的一个接口中，因为由于Activity状态的改变，你的Activity的Layout就有可能会被改变。说到这里就要谈一下什么叫做Layout，每个Activity的界面的布局就是一个Layout，每个Activity都要有这样一个布局它才能够被显示出来，一般地，我们都会把一个Layout放到一个XML文件当中，然后直接调用Activity的setContentView函数来填充这个Activity，如果Layout不放在xml文件中，也可以用代码生成一个动态的Layout，也就是说用Activity。

this指针生成一个Layout。这个给大家推荐一个非常好用的工具叫做droiddraw，论坛里就有链接，站长好像发过贴。这个工具非常好用，不用看教程半小时就能学会，上面有一些特定的控件，把控件摆好布局后直接能生成xml文件。把这个xml文件放到项目的res/layout文件夹下面就可以了。生成好Layout文件后，你就要为你程序要用到的一些控件设定ID，具体怎么设定大家可以在google的Android主页里有，叫gettingstarted，那个写得很明白，我就不跟这里重述了。

接下来还是谈下Android的这几个主要的函数，我还有些建议就是在onCreate函数中尽量少写代码，把尽肯能多的东西放到onResume和那个自定义的初始化函数里去写，onResume这个函数被调用的几率是非常高的，这里大家在模拟器上开发可能没有感觉到onResume的重要性，在真机上测试就会发现，当屏幕变黑进入等待状态，然后你手动恢复屏幕变亮时也会进入onResume状态，所以我感觉把一些刷新控件的方法放到onResume函数中来做还是非常必要的。onPause，onStop，还有onDestroy函数都是用来做一些清理工作的，比如说一些变量要被释放，一些线程要被停滞等等都可以放到这里来做。

下面我来总结一下Android Activity类一个大概的设计思路:

首先设计一个方法，这个方法主要作用就是初始化Activity的控件，进行各种条件判断，对Acitvity来进行不用的布局初始化，这里举个例子来解释下为什么要初始化不同的布局，例如你的这个Activity从SD卡读取了一些信息，那么当你拔出SD卡的时候这些信息肯定也就没有了，那么你就要进行另外的一个布局来显示这个Activity，这个时候你就可以重用这个函数来进行布局的初始化。

onCreate函数:注册你要用到的变量，比如说service，receiver，这些变量是无论你的Activity是在前台还是在后台都能够被响应到的，然后调用上面那个用来初始化的函数初始化布局信息。

onStart函数:注册一些变量。这些变量必须在Android Activity类在前台的时候才能够被响应。

onResume函数:调用一些刷新UI的函数，每当Activity调用到这里时就要刷新一下UI各控件的状态。

onPause函数:一般是做一些变量的设置，因为这个时候Activity马上就要切到后台处理，可能有些变量就要被释放掉或者状态要做些相应的调整。

onStop函数:反注册在onStart函数中注册的变量。

onDestory函数:反注册在onCreate函数中注册的变量。

上面谈了些Android Activity类的最常用的一些方法，当然还有很多方法没有谈到，有很多方法我也没有用过，其他方法大家可以参考google的文档。

接下来我来谈谈Activity中最简单的一些通信方法，这里我先定义两个名字为方便接下来的叙述，启动另外一个Activity的那个Activity我们称之为主Activity，被启动的那个Activity我们称之为子Activity。

主Activity和子Acitivity通信的方式有很多种这里介绍两种最简单的方法。

方法一:通过Intent来进行参数的传递，在Intent中有各种putXXX方法来存放各种参数，然后在子Activity接收到这个Intent时能够从这个Intent里取出这个参数，利用getIntnet()。getXXXExtra()方法就可以了。

方法二:当一个主Activity想从一个子Activity接受消息时可以使用StartActivityforResult方法，例如这样启动一个Activity，startActivityForResult(i， REQUEST_CODE); 然后在主Activity中的onActivityResult方法对requestCode进行判断来对子Android Activity类不同的返回处理不同的情况，另外子Activity也可以利用setResult方法来设置主Activity方法中的resultCode，这样主Activity也可以根据子Activity的不同的resultCode来处理不同的情况。

Android中Activity

第一步：新建一个继承Activity的类，如：NewActivity

publicclassNewActivityextendsActivity{

@OverrideprotectedvoidonCreate(BundlesavedInstanceState){

super.onCreate(savedInstanceState);

//这里可以使用setContentView(R.layout.xxx)显示某个视图....

}

第二步：需要在功能清单AndroidManifest.xml文件中添加进上面Activity配置代码(红色部分)：

<manifestxmlns:android="http://schemas.android.com/apk/res/android"

package="cn.itcast.action"

android:versionCode="1"

android:versionName="1.0">

<applicationandroid:icon="@drawable/icon"android:label="@string/app_name">

.....

<activityandroid:name=".NewActivity"android:label="新activity的页面标题"/>

</application>

...

</manifest>

android:name属性值的前面加了一个点表示NewActivity是当前包cn.itcast.action下的类，如果类在应用的当前包下，可以省略点符号，如果类在应用的子包下必须加点，如：NewActivity类在cn.itcast.action.user包下可以这样写：<activityandroid:name=“.user.NewActivity“/>

打开新的Activity，不传递参数

在一个Activity中可以使用系统提供的startActivity(Intentintent)方法打开新的Activity，在打开新的Activity前，你可以决定是否为新的Activity传递参数：

第一种：打开新的Activity，不传递参数

publicclassMainActivityextendsActivity{

@OverrideprotectedvoidonCreate(BundlesavedInstanceState){

.......

Buttonbutton=(Button)this.findViewById(R.id.button);

button.setOnClickListener(newView.OnClickListener(){//点击该按钮会打开一个新的Activity

publicvoidonClick(Viewv){

//新建一个显式意图，第一个参数为当前Activity类对象，第二个参数为你要打开的Activity类

startActivity(newIntent(MainActivity.this,NewActivity.class));

}});

}

打开新的Activity，并传递若干个参数给它

第二种：打开新的Activity，并传递若干个参数给它：

publicclassMainActivityextendsActivity{

@OverrideprotectedvoidonCreate(BundlesavedInstanceState){

.......

button.setOnClickListener(newView.OnClickListener(){//点击该按钮会打开一个新的Activity

publicvoidonClick(Viewv){

Intentintent=newIntent(MainActivity.this,NewActivity.class)

Bundlebundle=newBundle();//该类用作携带数据

bundle.putString("name","传智播客");

bundle.putInt("age",4);

intent.putExtras(bundle);//附带上额外的数据

startActivity(intent);

}});}

}

在新的Activity中接收前面Activity传递过来的参数：

publicclassNewActivityextendsActivity{

@OverrideprotectedvoidonCreate(BundlesavedInstanceState){

........

Bundlebundle=this.getIntent().getExtras();

Stringname=bundle.getString("name");

intage=bundle.getInt("age");

}

Activity生命周期

Activity有三个状态：

当它在屏幕前台时（位于当前任务堆栈的顶部），它是激活或运行状态。它就是响应用户操作的Activity。

当它上面有另外一个Activity，使它失去了焦点但仍然对用户可见时（如右图），它处于暂停状态。在它之上的Activity没有完全覆盖屏幕，或者是透明的，被暂停的Activity仍然对用户可见，并且是存活状态（它保留着所有的状态和成员信息并保持和窗口管理器的连接）。如果系统处于内存不足时会杀死这个Activity。

当它完全被另一个Activity覆盖时则处于停止状态。它仍然保留所有的状态和成员信息。然而对用户是不可见的，所以它的窗口将被隐藏，如果其它地方需要内存，则系统经常会杀死这个Activity。

当Activity从一种状态转变到另一种状态时，会调用以下保护方法来通知这种变化：

voidonCreate(BundlesavedInstanceState)

voidonStart()

voidonRestart()

voidonResume()

voidonPause()

voidonStop()

voidonDestroy()

这七个方法定义了Activity的完整生命周期。实现这些方法可以帮助我们监视其中的三个嵌套生命周期循环：

Activity的完整生命周期自第一次调用onCreate()开始，直至调用onDestroy()为止。Activity在onCreate()中设置所有“全局”状态以完成初始化，而在onDestroy()中释放所有系统资源。例如，如果Activity有一个线程在后台运行从网络下载数据，它会在onCreate()创建线程，而在onDestroy()销毁线程。

Activity的可视生命周期自onStart()调用开始直到相应的onStop()调用结束。在此期间，用户可以在屏幕上看到Activity，尽管它也许并不是位于前台或者也不与用户进行交互。在这两个方法之间，我们可以保留用来向用户显示这个Activity所需的资源。例如，当用户不再看见我们显示的内容时，我们可以在onStart()中注册一个BroadcastReceiver来监控会影响UI的变化，而在onStop()中来注消。onStart()和onStop()方法可以随着应用程序是否为用户可见而被多次调用。

Activity的前台生命周期自onResume()调用起，至相应的onPause()调用为止。在此期间，Activity位于前台最上面并与用户进行交互。Activity会经常在暂停和恢复之间进行状态转换——例如当设备转入休眠状态或者有新的Activity启动时，将调用onPause()方法。当Activity获得结果或者接收到新的Intent时会调用onResume()方法。关于前台生命周期循环的例子请见PPT下方备注栏。

Activity的前台生命周期循环例子:

1》创建一个Activity，添加七个生命周期方法，方法内输出各个方法名称。再添加一个按钮用于打开下面新添加的Activity。

startActivity(newIntent(LifeActivity.this,CustomDialogActivity.class));

2》添加一个新Activity，代码如下：

publicclassCustomDialogActivityextendsActivity{

@OverrideprotectedvoidonCreate(BundlesavedInstanceState){

super.onCreate(savedInstanceState);

//必须在调用setContentView()之前调用requestWindowFeature()

requestWindowFeature(Window.FEATURE_LEFT_ICON);//要标题栏显示图标

setContentView(R.layout.dialog_activity);

getWindow().setFeatureDrawableResource(Window.FEATURE_LEFT_ICON,android.R.drawable.ic_dialog_alert);//设置图标

}

3》在AndroidManifest.xml文件配置Activity，并且通过主题指定该Activity以对话框样式显示。

<applicationandroid:icon="@drawable/icon"android:label="@string/app_name">

.....

<activityandroid:name=".CustomDialogActivity"android:label="对话框activity"

android:theme="@android:style/Theme.Dialog"/>

</application>

Activity的onSaveInstanceState()和onRestoreInstanceState()方法

Activity的onSaveInstanceState()和onRestoreInstanceState()并不是生命周期方法，它们不同于onCreate()、onPause()等生命周期方法，它们并不一定会被触发。当应用遇到意外情况（如：内存不足、用户直接按Home键）由系统销毁一个Activity时，onSaveInstanceState()才会被调用。但是当用户主动去销毁一个Activity时，例如在应用中按返回键，onSaveInstanceState()就不会被调用。因为在这种情况下，用户的行为决定了不需要保存Activity的状态。通常onSaveInstanceState()只适合用于保存一些临时性的状态，而onPause()适合用于数据的持久化保存。

另外，当屏幕的方向发生了改变，Activity会被摧毁并且被重新创建，如果你想在Activity被摧毁前缓存一些数据，并且在Activity被重新创建后恢复缓存的数据。可以重写Activity的onSaveInstanceState()和onRestoreInstanceState()方法，如下：

publicclassPreferencesActivityextendsActivity{

privateStringname;

protectedvoidonRestoreInstanceState(BundlesavedInstanceState){

name=savedInstanceState.getString("name");//被重新创建后恢复缓存的数据

super.onRestoreInstanceState(savedInstanceState);

}

protectedvoidonSaveInstanceState(BundleoutState){

outState.putString("name","liming");//被摧毁前缓存一些数据

super.onSaveInstanceState(outState);

}

应用的响应性（Responsive）

在Android中，应用的响应性被活动管理器（ActivityManager）

和窗口管理器（WindowManager）这两个系统服务所监视。

当用户触发了输入事件（如键盘输入，点击按钮等），

如果应用5秒内没有响应用户的输入事件，那么，Android会认

为该应用无响应，便弹出ANR（ApplicationNoResponse）

对话框。如右图。

在正常情况下，Android程序会在一条单线程里运行。如果Activity要处理一件比较耗时的工作，应该交给子线程完成，否侧会因为主线程被阻塞，后面的用户输入事件因没能在5秒内响应，导致应用出现ANR对话框。

Activity是最基本的Android 应用程序组件，应用程序中，一个活动通常就是一个单

独的屏幕。每一个活动都被实现为一个独立的类，并且从活动基类中继承而来，活动类将会显示由视图控件组成的用户接口，并对事件做出响应。

大多数的应用是由多个屏幕显示组成。例如:一个文本信息的应用也许有一个显示发送消息的联系人列表屏幕，第二个屏幕用来写文本消息和选择收件人，再来一个屏幕查看消息历史或者消息设置操作等。这里每一个这样的屏幕就是一个活动，很容易实现从一个屏幕到一个新的屏幕并且完成新的活动。在某些情况下当前的屏幕也许需要向上一个屏幕活动提供返回值--比如让用户从手机中挑选一张照片返回通讯录做为电话拨入者的头像。

当一个新的屏幕打开后，前一个屏幕将会暂停，并保存在历史堆栈中。用户可以返回到历史堆栈中的前一个屏幕。当屏幕不再使用时，还可以从历史堆栈中删除。默认情况下，Android 将会保留从主屏幕到每一个应用的运行屏幕。

简单理解Activity 代表一个用户所能看到的屏幕，Activity 主要是处理一个应用的整体性工作，例如，监听系统事件(按键事件、触摸屏事件等)、为用户显示指定的View，启动其他Activity 等。

所有应用的Activity都继承于android.app.Activity类，该类是Android 提供的基层类，其他的Activity 继承该父类后，通过Override父类的方法来实现各种功能，这种设计在其他领域也较为常见。

最简单的就是你可以把Activity 看成一个User Interface Program，原则上它会提供使用者一个交互式的接口功能，那一个Activity 只有一个UI 吗？非也，举例来说：一个email 程序，就可能包含几个Activity.

理解Activity的生命周期对于构建稳定的应用程序非常重要。运行Android应用程序及其组件的进程回经历各种生命周期事件，Android提供了回调，通过实现他们可以处理状态的变化。

Activity的生命周期包括：

protected void onCreate(Bundle saveInstanceState);

protected void onStart();

protected void onRestart();

protected void onResume();

protected void onPause();

protected void onStop();

protected void onDestory();

生命周期转换图

理解Activity的生命周期图对于开发人员来说至关重要。

区分Activity的四种加载模式

转载：http://marshal.easymorse.com/archives/2950

在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。

加载模式分类及在哪里配置

Activity有四种加载模式：

standard
singleTop
singleTask
singleInstance

设置的位置在AndroidManifest.xml文件中activity元素的android:launchMode属性：

<activity android:name="ActB"android:launchMode="singleTask"></activity>

也可以在Eclipse ADT中图形界面中编辑：

区分Activity的加载模式，通过示例一目了然。这里编写了一个Activity A（ActA）和Activity B（ActB）循环跳转的例子。对加载模式修改和代码做稍微改动，就可以说明四种模式的区别。

standard

首先说standard模式，也就是默认模式，不需要配置launchMode。先只写一个名为ActA的Activity：

package com.easymorse.activities;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;

public class ActA extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView textView = new TextView(this);
textView.setText(this + "");
Button button = new Button(this);
button.setText("go actA");
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setClass(ActA.this, ActA.class);
startActivity(intent);
}
});
LinearLayout layout = new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
layout.addView(textView);
layout.addView(button);
this.setContentView(layout);
}
}

例子中都没有用layout，免得看着罗嗦。可见是ActA –> ActA的例子。在界面中打印出对象的toString值可以根据hash code识别是否创建新ActA实例。

第一个界面：

点击按钮后：

可以多点几次。发现每次都创建了该Activity的新实例。standard的加载模式就是这样的，intent将发送给新的实例。

现在点Android设备的回退键，可以看到是按照刚才创建Activity实例的倒序依次出现，类似退栈的操作，而刚才操作跳转按钮的过程是压栈的操作。如下图：

singleTop

singleTop 和standard模式，都会将intent发送新的实例（后两种模式不发送到新的实例，如果已经有了的话）。不过，singleTop要求如果创建 intent的时候栈顶已经有要创建的Activity的实例，则将intent发送给该实例，而不发送给新的实例。

还是用刚才的示例，只需将launchMode改为singleTop，就能看到区别。

运行的时候会发现，按多少遍按钮，都是相同的ActiA实例，因为该实例在栈顶，因此不会创建新的实例。如果回退，将退出应用。

singleTop模式，可用来解决栈顶多个重复相同的Activity的问题。

如果是A Activity跳转到B Activity，再跳转到A Activity，行为就和standard一样了，会在B Activity跳转到A Activity的时候创建A Activity的新实例，因为当时的栈顶不是A Activity实例。

ActA类稍作改动：

package com.easymorse.activities;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;

public class ActA extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView textView = new TextView(this);
textView.setText(this + "");
Button button = new Button(this);
button.setText("go actB");
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setClass(ActA.this, ActB.class);
startActivity(intent);
}
});
LinearLayout layout = new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
layout.addView(textView);
layout.addView(button);
this.setContentView(layout);
}
}

ActB类：

package com.easymorse.activities;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;

public class ActB extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Button button=new Button(this);
button.setText("go actA");
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent=new Intent();
intent.setClass(ActB.this, ActA.class);
startActivity(intent);
}
});
LinearLayout layout=new LinearLayout(this);
layout.addView(button);
this.setContentView(layout);
}
}

ActB类使用默认（standard）加载，ActA使用singleTop加载。结果类似下图：

如果把ActA的加载模式改为standard，情况一样。

singleTask

singleTask模式和后面的singleInstance模式都是只创建一个实例的。

当intent到来，需要创建singleTask模式Activity的时候，系统会检查栈里面是否已经有该Activity的实例。如果有直接将intent发送给它。

把上面singleTop的实例中的ActA的launchMode改为singleTask，ActB的改为standard。那么会发现在ActA界面中按一次按钮：

然后在ActB1界面中按按钮，因为ActA是singleTask，会使用原来的ActA1实例。这时候栈内的情况:

如果多次按按钮跳转，会发现始终只有ActA1这一个ActA类的实例。

singleInstance

解释singleInstance模式比较麻烦。

首先要说一下Task（任务）的概念。

如果是Swing或者Windows程序，可能有多个窗口可以切换，但是你无法在自己程序中复用人家的窗口。注意是直接复用人家的二进制代码，不是你拿到人家api后的源代码级调用。

Android可以做到，让别人的程序直接复用你的Activity（类似桌面程序的窗口）。

Android 为提供这种机制，就引入了Task的概念。Task可以认为是一个栈，可放入多个Activity。比如启动一个应用，那么Android就创建了一个 Task，然后启动这个应用的入口Activity，就是intent-filter中配置为main和launch的那个（见一个APK文件部署产生多个应用安装的效果）。这个Activity是根（Root）Activity，可能会在它的界面调用其他Activity，这些Activity如果按照上面那三个模式，也会在这个栈（Task）中，只是实例化的策略不同而已。

验证的办法是调用和打印Activity的taskId：

TextView textView2 = new TextView(this);
textView2.setText("task id: "+this.getTaskId());

会发现，无论切换Activity，taskId是相同的。

当然也可以在这个单一的Task栈中，放入别人的Activity，比如google地图，这样用户看过地图按回退键的时候，会退栈回到调用地图的Activity。对用户来说，并不觉得在操作多个应用。这就是Task的作用。

但是，有这样的需求，多个Task共享一个Activity（singleTask是在一个task中共享一个Activity）。

现成的例子是google地图。比如我有一个应用是导游方面的，其中调用的google地图Activity。那么现在我比如按home键，然后到应用列表中打开google地图，你会发现显示的就是刚才的地图，实际上是同一个Activity。

如果使用上面三种模式，是无法实现这个需求的。google地图应用中有多个上下文Activity，比如路线查询等的，导游应用也有一些上下文Activity。在各自应用中回退要回退到各自的上下文Activity中。

singleInstance模式解决了这个问题（绕了这么半天才说到正题）。让这个模式下的Activity单独在一个task栈中。这个栈只有一个Activity。导游应用和google地图应用发送的intent都由这个Activity接收和展示。

这里又有两个问题：

如果是这种情况，多个task栈也可以看作一个应用。比如导游应用启动地图Activity，实际上是在导游应用task栈之上 singleInstance模式创建的（如果还没有的话，如果有就是直接显示它）一个新栈，当这个栈里面的唯一Activity，地图Activity 回退的时候，只是把这个栈移开了，这样就看到导游应用刚才的Activity了；
多个应用（Task）共享一个Activity要求这些应用都没有退出，比如刚才强调要用home键从导游应用切换到地图应用。因为，如果退出导游应用，而这时也地图应用并未运行的话，那个单独的地图Activity（task）也会退出了。

如果还是拿刚才的ActA和ActB的示例，可以把ActB的模式改为singleInstance，ActA为standard，如果按一次按钮切换到ActB，看到现象用示意图类似这样：

如果是第一次按钮切换到ActB，在ActB在按按钮切换到ActA，然后再回退，示意图是：

另外，可以看到两个Activity的taskId是不同的。

9、Android中Activity

区分Activity的四种加载模式

加载模式分类及在哪里配置

standard

singleTop

singleTask

singleInstance

更多相关文章

随机推荐