03-04-Android开发技术讲义之启动另一个Activity

合集下载

Android开发入门之四大组件Activity启动

Android开发中，Activity是四大组件之一，也是Android开发入门初学者必须重点掌握的内容之一，而要掌握Activity的启动模式，首先要学习的就是任务栈。

任务栈Task ，是一种用来放置Activity实例的容器，他是以栈的形式进行盛放，也就是所谓的先进后出，主要有2个基本操作：压栈和弹出，所以在其中只能根据压栈和弹出操作更改Activity的顺序。

启动一个Application的时候，系统会为它默认创建一个对于的Task，用来放置根Activity。

Android软件开发学习Activity组件启动模式方法Activity启动模式在安卓中，Activity的启动模式分为四种，分别是：标准模式，栈顶复用模式，栈内复用模式，单例模式。

1、standard 即标准模式，他是系统默认的启动方式，这个任务栈中可以有多个相同的Activity实例，多个相同Activity实例也可以分布在不同的任务栈中，这时候是谁启动他，他就和谁在一个任务栈中。

这时候我们要联系到我们遇到过的一个常：android.util.AndroidRuntimeException:....，具体内容大家试试这样启动一个Activity就会出来，使用ApplicationContext启动一个standard模式的Activity。

我们分析下，其实这个错误的出现就是因为默认模式下，被谁启动，activity就翻到那个任务栈中去，而全局的上下文对象是没有任务栈存在的，所以就会报错了。

解决这个问题可以更改启动的上下文为某个activity 对象，当然我们如果将被启动的activity设置他的标志位为FLAG_ACTIVITY_NEW_TASK 也同样可以，这时候就相当于把Activity改为了singleTask模式启动了。

2、singleTop 即栈顶唯一模式，这种模式下，如果Activity位于任务栈的栈顶，那么此Activity 不会被重新创建，也就是说不会调用生命周期中的onCreate和onStart 方法，但是会回调另一个方法onNewIntent ，这时候我们可以在这个回调方法里根据参数Intent intent进行自己的相关处理。

android中activity的作用

android中activity的作用
Android中的Activity是一种Android应用程序组件，它是应
用程序用户界面的基本单元之一，用于展示用户界面，并处理与用户交互的事件。

Activity可以执行各种任务，包括呈现一
个布局、启动另一个Activity、接收用户输入、显示对话框、
与数据库等数据存储进行交互等。

以下是Activity的主要作用：
1. 展示用户界面：Activity是用来呈现用户界面的，它可以包
括布局、按钮、文本框、图像和其他UI组件。

2. 处理用户输入：Activity可以监听用户的交互操作，比如点
击一个按钮或文本框输入等。

3. 启动其他Activity：应用程序通常涉及多个Activity，一个Activity可以启动其他Activity，以便用户可以浏览应用程序
的不同部分。

4. 保存和恢复状态：当设备配置更改或系统内存不足时，Activity可以保存其状态并在需要时进行恢复。

5. 数据交互： Activity可以与其他应用程序进行数据交互，例
如通过Intent与其他Activity进行通信，与数据库进行交互等。

Android一个app启动另一个app

Android⼀个app启动另⼀个app最近，⼀个app启动另⼀个app，这个玩法挺⽕的嘛，有没有试过更新QQ到5.1版本，QQ的健康⾥⾯就可以添加其他app,实现从QQ跳转到其他app应⽤。

这个挺好玩的，⼀下⼦带来了多少流量啊。

⼀、先来⼏⾏代码，⼀个app启动另⼀个app// 通过包名获取要跳转的app，创建intent对象Intent intent = getPackageManager().getLaunchIntentForPackage("com.example.liuxiang");// 这⾥如果intent为空，就说名没有安装要跳转的应⽤嘛if (intent != null) {// 这⾥跟Activity传递参数⼀样的嘛，不要担⼼怎么传递参数，还有接收参数也是跟Activity和Activity传参数⼀样intent.putExtra("name", "Liu xiang");intent.putExtra("birthday", "1983-7-13");startActivity(intent);} else {// 没有安装要跳转的app应⽤，提醒⼀下Toast.makeText(getApplicationContext(), "哟，赶紧下载安装这个APP吧", Toast.LENGTH_LONG).show();}这⾥或许⽹上有很多类似代码，还是提⼀下，让⼤家知道流程。

⼆、被启动的app如何获取参数呢？public class MainActivity extends Activity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);Intent intent = getIntent();Bundle bundle = intent.getExtras();if (bundle != null) {String name = bundle.getString("name");String birthday = bundle.getString("birthday");if (name != null && birthday != null) {Toast.makeText(getApplicationContext(), "name:" + name + " birthday:" + birthday, Toast.LENGTH_SHORT).show();}}}}在被打开的app应⽤，也是简单地⼏⾏代码可以接收到传过来的参数信息。

activity流程操作

activity流程操作Activity是Android应用程序中的一个重要组件，它负责管理用户界面和用户交互。

在Android开发中，我们经常需要对Activity进行流程操作，以实现不同的功能和交互效果。

本文将介绍一些常见的Activity流程操作，帮助开发者更好地理解和使用Activity组件。

1. 启动Activity启动Activity是Android应用程序中最基本的操作之一。

我们可以通过Intent对象来启动一个新的Activity，并传递数据给新的Activity。

例如，我们可以通过以下代码启动一个新的Activity：```javaIntent intent = new Intent(this, SecondActivity.class);intent.putExtra("key", "value");startActivity(intent);```在新的Activity中，我们可以通过getIntent()方法获取传递过来的数据，并进行相应的处理。

2. 生命周期管理Activity有多个生命周期方法，如onCreate()、onStart()、onResume()、onPause()、onStop()和onDestroy()等。

我们可以通过这些生命周期方法来管理Activity的状态和行为。

例如，我们可以在onCreate()方法中进行初始化操作，在onResume()方法中进行界面更新操作，在onPause()方法中保存数据等。

3. 返回数据在Activity之间进行数据交换是常见的操作。

我们可以通过startActivityForResult()方法启动一个新的Activity，并在新的Activity中通过setResult()方法返回数据给上一个Activity。

例如，我们可以通过以下代码启动一个新的Activity并获取返回数据：```javaIntent intent = new Intent(this, SecondActivity.class);startActivityForResult(intent, REQUEST_CODE);```在新的Activity中，我们可以通过以下代码返回数据给上一个Activity：```javaIntent intent = new Intent();intent.putExtra("result", "data");setResult(RESULT_OK, intent);finish();```在上一个Activity中，我们可以通过onActivityResult()方法获取返回的数据，并进行相应的处理。

android开发教程1.1.4启动其他的Activity

启动其他的Activity在完成上一课(建立简单的用户界面)后，你已经拥有了显示一个activity（唯一屏幕）的app（应用），并且这个activity包含了一个文本字段和一个按钮。

在这节课中，你将会添加一些新的代码到MainActivity中，当用户点击发送(Send)按钮时启动一个新的activity。

响应Send(发送)按钮响应按钮的on-click(点击)事件，打开fragment_main.xml布局文件然后在Button(按钮)元素中添加android:onclick属性:<Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@string/button_send"android:onClick="sendMessage" //sendMessage is the method name/>android:onclick属性的值"sendMessage"就是当用户点击你屏幕按钮时触发方法的名字。

添加相应的方法在MainActivity类中：/** 当用户点击按钮时会被调用 */public void sendMessage(View view){// 响应按钮的事件处理逻辑}请注意，为了让系统能够将这个方法（你刚在MyFirstActivity中添加的sendMessage方法）与在android:onClick属性中提供的方法名字匹配，它们的名字必须一致，特别是，这个方法必须满足以下条件：∙公共的∙没有返回值∙有唯一的视图（View）参数（这个视图就是将被点击的视图）接下来，你可以在这个方法中编写读取文本内容的代码，并将该内容传到另一个Activity。

android 系统的activity 使用规则

android 系统的activity 使用规则
在Android系统中，Activity的使用有一些关键规则和最佳实践。

以下是一些重要的规则和注意事项：
1. 重写onCreate方法：每个Activity都应重写Activity的onCreate方法。

2. 使用Toast：在活动中使用Toast来显示短时间的信息。

例如，(, "You clicked Button1", _SHORT).show();。

3. 使用Intent启动活动：可以使用显式Intent启动另一个Activity。

例如，Intent intent = new Intent(, ); startActivity(intent);。

4. 在中注册：活动必须在中注册才能生效。

5. 使用Menu：如果需要在活动中使用菜单，可以重写onCreateOptionMenu和onOptionsItemSelected方法。

Menu布局必
须放在menu文件夹下面。

6. 保存Activity的临时数据：Activity中提供了一个onSaveInstanceState(Bundle outState)回调方法，这个方法保证一定在Activity被回收时调用，因此可以通过这个方法来临时保存所需数据。

遵循这些规则和最佳实践可以确保你的Activity表现正常，提供良好的用户体验，并符合Android系统的设计原则。

activity的启动流程

activity的启动流程Android Activity启动流程1. 启动Activity过程：（1）Android系统接收到启动Activity的命令后，首先会根据当前任务栈检查当前任务中是否有此Activity；（2）如果当前任务中存在此Activity，则Activity将回到栈顶；如果不存在，则新建Activity；（3）即生成一个新的Activity实例，然后通过calling attach(IBinder token)调用连接到ActivityThread处理并添加到任务栈；2. Activity对象创建过程：（1）ActivityThread会调用handleLaunchActivity(ActivityClientRecord r)方法，创建Activity对象；（2）先根据<activity>在AndroidManifest.xml中的定义，加载此Activity对应的class（Activity引用AppClassLoader加载）；（3）然后在LoadedApk类中调用makeActivity（）方法创建此Activity对象；3. Activity实例化过程：（1）ActivityThread会先调用handleResumeActivity方法创建一个新的Activity实例；（2）然后调用performCreate()方法，进而调用onCreate()方法，从而Activity实例化。

4. Activity与Window的关联：（1）ActivityThread在handleResumeActivity()之后会调用performResume()方法，与Window进行关联；（2）performResume()方法会调用Window.setWindowManager()方法，然后通过Window.addContentView()，将当前Activity的ContentView添加到窗口中；5. Activity可见：（1）接着，ActivityThread会调用Activity的onStart()方法，此时Activity变成可见的；（2）接着调用onResume()方法，此Activity可见且处于运行状态。

activity 启动的方法

activity 启动的方法Activity启动的方法在Android开发中，Activity是应用程序的核心组件之一，它负责提供用户界面和处理用户交互。

为了启动一个Activity，我们可以使用以下几种方法：1. 使用显式Intent启动Activity：通过显式Intent指定要启动的Activity的类名，然后调用startActivity()方法即可启动该Activity。

例如：```Intent intent = new Intent(CurrentActivity.this, TargetActivity.class);startActivity(intent);```2. 使用隐式Intent启动Activity：使用隐式Intent启动Activity时，我们只需指定一些动作（Action）或者数据（Data），然后系统会自动找到合适的Activity来响应该Intent。

例如： ```Intent intent = new Intent("com.example.ACTION_SOME_ACTION");startActivity(intent);```3. 带返回结果的启动：有时候，我们需要从被启动的Activity中获取结果。

这时，我们可以使用startActivityForResult()方法启动Activity，并在目标Activity中通过setResult()方法返回结果。

例如：```Intent intent = new Intent(CurrentActivity.this, TargetActivity.class);startActivityForResult(intent, REQUEST_CODE);```在目标Activity中，我们可以通过Intent将结果返回给调用方：```Intent resultIntent = new Intent();resultIntent.putExtra("result", "success");setResult(RESULT_OK, resultIntent);finish();```4. 使用Task和Back Stack来管理Activity的启动：在Android系统中，Activity是通过任务（Task）和后退栈（Back Stack）来管理的。

activity 的启动流程

activity 的启动流程Activity 的启动流程1. 概述•Activity 是 Android 开发中最常用的组件之一，它代表应用程序的一个屏幕。

•在 Android 中，启动一个 Activity 需要经历以下几个流程。

2. 启动方式•启动一个 Activity 可以使用以下两种方式：–显式启动：通过指定 Activity 的类名启动。

–隐式启动：通过指定 Intent 的 Action 和 Category 信息启动。

3. 显式启动流程创建 Intent 对象•首先，需要创建一个 Intent 对象，用于启动目标 Activity。

设置 Intent 的 Component•通过调用 Intent 的 setComponent 方法，设置目标 Activity 的包名和类名。

启动 Activity•使用 startActivity 方法，传入 Intent 对象，启动目标Activity。

4. 隐式启动流程创建 Intent 对象•同样需要创建一个 Intent 对象，用于启动目标 Activity。

设置 Intent 的 Action 和 Category•通过调用 Intent 的 setAction 方法，设置目标 Activity 的Action 信息。

•通过调用 Intent 的 addCategory 方法，设置目标 Activity 的 Category 信息。

启动 Activity•使用 startActivity 方法，传入 Intent 对象，启动目标Activity。

5. 生命周期方法•在 Activity 启动的过程中，系统会调用一系列的生命周期方法，用于管理 Activity 的状态和行为。

•常用的生命周期方法包括 onCreate、onStart、onResume 等。

6. 特殊情况处理•在启动过程中，可能会遇到一些特殊情况，需要进行特殊处理，例如权限请求、Activity 栈管理等。

activity启动原理

activity启动原理Activity的启动原理涉及到Android系统的多个组件和机制。

以下是Activity启动的基本原理：1.ActivityManagerService：Activity管理的核心是ActivityManagerService（AMS），它是一个独立的进程，负责管理系统中所有的Activity实例。

AMS维护了一个Activity记录列表，记录了系统中所有Activity的状态和信息。

2.启动过程：当一个Activity需要启动时，首先会通过AMS的startActivity()方法进行启动。

这个方法会根据传入的Intent信息找到需要启动的Activity实例，并通知到相应的应用程序进程。

3. 应用程序进程：每个应用程序都会有一个对应的进程，进程中运行着一个主线程（即ActiveThread）。

ActiveThread循环处理消息，包括处理Activity的启动请求。

4. 进程间通信：ActiveThread与AMS的通信属于进程间通信，使用Binder机制进行通信。

ActiveThread通过代理模式启动到AMS中执行，创建ActivityRecord并加入到AMS的mHistory记录中。

5. 创建Activity实例：在应用程序进程中，ActiveThread会根据AMS的指令创建相应的Activity实例，并将其加入到mActivities中。

6. 开始调度：当Activity实例创建完成后，会进行相应的调度和处理，包括加载资源、创建视图等操作，以便用户能够看到和交互。

总之，Activity的启动过程涉及到Android系统的多个组件和机制，通过AMS、ActiveThread等组件的协作，实现了Activity的启动和管理。

android启动activity的几种方式

android 启动activity 的几种方式跳转activity 的几种方式，主要是通过intent 意图，分为显示和隐式intent1.显示跳转A.class 跳转用例：1 2 3 Intent it = new Intent(A.this,B.class);//it.putExtra("key","value"); //跳转时传的参数startActivity(it);使用场景：应用内部跳转，频率较高B.包名、类名跳转用例：1 2 3 4 Intent it= new Intent();it.setClassName("cn.thear","cn.thear.MainActivity"); //包名和类名 //it.putExtra("key","value"); //传一些参数startActivity(it);使用场景：内部跳转+外部跳转。

ponentName 跳转用例：1 2 3 4 Intent it= new Intent();it.setComponent(newComponentName(<span></span>"cn.thear","cn.thear.MainActivity")); //包名和类名//it.putExtra("key","value"); //传一些参数startActivity(it);使用场景：内部跳转+外部跳转。

注：在外部跳转时，当要跳转第三应用时，只知道包名和类名，就推荐用B 或C 跳转了。

但这个不是特别灵活，比如在要跳转的activity 前有个过渡初始化页面时，那直接跳过去肯定会出问题的啦。

2.隐式跳转1 2 3 Intent it = new Intent("com.custom.skip.action");//参数要跳转的activity 中定义的action 名，这个action 是在androidManifest.sml 中定义 //it.putExtra("key","value"); //跳转时传的参数 startActivity(it);使用场景：内部跳转+外部跳转。

Android启动activity的4种方式及打开其他应用的activity的坑

Android启动activity的4种⽅式及打开其他应⽤的activity的坑Android启动的四种⽅式分别为standard，singleTop，singleTask，singleInstence。

standard是最常见的activity启动⽅式，也是默认的启动的⽅式。

当启动⼀个activity的时候他将进⼊返回栈的栈顶。

系统不会管栈内是否有相同的activity，⽅式像后⼊先出。

singleTop⽅式是在活动启动的时候，系统先判定栈顶是否有相同的活动，如果没有则新建活动，否则将不新建活动。

⽽是直接使⽤他。

singleTask⽅式在活动启动的时候，系统先判定栈中是否有该活动的实例，如果没有这新建实例，如果有则将已有活动上⾯的栈都出栈。

singleInstance⽅式在启动的时候会新建⼀个栈，当别的程序访问这个活动启动这个活动的时候得到的也是这个实例，所有应⽤访问的都是同⼀个实例。

在实验别的应⽤B访问具有singleInstance启动模式的活动A的时候需要注意要在A应⽤的AndroidManifest.xml中加⼊<activityandroid:name="com.example.testandroid.BActivity"android:exported="true" ></activity>android:exported="true"这是申明活动可以被其他应⽤打开以上所述是⼩编给⼤家介绍的Android 启动activity的4种⽅式及打开其他应⽤的activity的坑的相关知识，希望对⼤家有所帮助，如果⼤家有任何疑问请给我留⾔，⼩编会及时回复⼤家的。

在此也⾮常感谢⼤家对⽹站的⽀持！。

Android组件系列----当前Activity跳转到另一个Activity的详细过程

Android组件系列----当前Activity跳转到另⼀个Activity的详细过程【声明】欢迎转载，但请保留⽂章原始出处→_→【正⽂】⼀、如何在⼀个应⽤程序当中定义多个Activity：步骤如下：（1）定义⼀个类，继承Activity（2）在该类当中，复写Activity当中的onCreate()⽅法（3）在AndroidManifest.xml⽂件中注册该Activity详细解释如下：（1）定义⼀个类，继承Activity：在src⽂件夹⾥⾯的包中新建⼀个class⽂件，可命名为：SecondActivity.java（2）在该类当中，复写Activity当中的onCreate()⽅法：在菜单栏选择Source--->Override/Implement Methods，弹出框，选择其中的onCreate()⽅法：注：onCreate()⽅法是Activity运⾏的⼊⼝。

紧接着，在layout⽂件夹中，为该Activity添加布局⽂件：（⽂件名必须为⼩写）在该布局⽂件中添加⼀个 <TextView />在SecondActivity.java中设置该Activity所使⽤的布局⽂件，即在onCreate()⽅法中添加如下代码：setContentView(yout.second) ;（3）在AndroidManifest.xml⽂件中注册该Activity：（想要启动的Activity⼀定要先在Manifest⽂件中进⾏注册）打开AndroidManifest.xml⽂件，注意⾥⾯的Activity标签，即以下代码：1<activity2android:name="com.example.test0201_activity01.MainActivity"3 android:label="@string/app_name">4<intent-filter>5<action android:name="android.intent.action.MAIN"/>6<category android:name="UNCHER"/>7</intent-filter>8</activity>代码解释如下：02⾏：代表Activity的名字：包名+类名。

Android利用Intent启动和关闭Activity

Android利⽤Intent启动和关闭Activity⼀、简介Android应⽤程序中⼀般都有多个Activity，在Activity中，通过调⽤StartActivity⽅法，并在该⽅法的参数中传递Intent对象，就可以实现不同Activity之间的切换和数据传递。

通过StartActivity⽅法传递intent对象来启动另⼀个Activity时，可分为两类：l 显式启动：在创建的Intent对象中明确指定启动的是哪个Activity；l 隐式启动：安卓系统根据Intent的动作和数据决定应该启动哪个Activity。

1、显式启动Activity通过Intent显式启动⼀个Activity时，必须先创建⼀个Intent对象，并在该对象的构造函数中指明要启动的⽬标组件名。

例如：var intent = new Intent(this, typeof(Activity1));StartActivity(intent);在这种情况下，除了intent对象以外，没有其他⽅式可以匹配组件名。

2、隐式启动Activity隐式启动Activity是指Android系统根据过滤规则⾃动去匹配对应的Intent，即不需要在Intent对象中明确指明启动的是哪个Activity，⽽是让Android系统来决定应该启动谁。

在这种情况下，Android系统会⾃动匹配最适合处理intent的⼀个或多个Activity。

匹配的Activity可能是应⽤程序⾃⾝的，也可能是Android系统内置的，还可能是第3⽅应⽤程序提供的。

因此，隐式启动这种⽅式更强调了Android应⽤程序中组件的复⽤性。

注意，如果希望让你的程序通过Activity展⽰某些动作，例如打电话、发邮件、发短信，或者使⽤activity中的数据等。

这时候，⾸先考虑调⽤系统提供的功能去实现（即：隐式启动Activity的⽅式）。

在这种情况下，只需要通过Intent指定相应的动作即可，这是intent真正体现其价值的地⽅。

启动一个Activity的几种方式

启动⼀个Activity的⼏种⽅式在Android中我们可以通过下⾯两种⽅式来启动⼀个新的Activity,注意这⾥是怎么启动，⽽⾮启动模式！！分为显⽰启动和隐式启动！1. 显式启动：通过包名来启动，写法如下：①最常见的：startActivity(new Intent(当前Act.this,要启动的Act.class));②通过Intent的ComponentName：ComponentName cn = new ComponentName("当前Act的全限定类名","启动Act的全限定类名") ;Intent intent = new Intent() ;intent.setComponent(cn) ;startActivity(intent) ;③初始化Intent时指定包名：Intent intent = new Intent("android.intent.action.MAIN");intent.setClassName("当前Act的全限定类名","启动Act的全限定类名");startActivity(intent);2.隐式启动：通过Intent-filter的Action,Category或data来实现这个是通过Intent的 intent-filter**来实现的，这个Intent那章会详细讲解！这⾥知道个⼤概就可以了！3. 另外还有⼀个直接通过包名启动apk的：Intent intent = getPackageManager().getLaunchIntentForPackage("apk第⼀个启动的Activity的全限定类名") ;if(intent != null) startActivity(intent) ;。

startactivity方法

startActivity() 是Android 开发中用于启动一个新的Activity 的方法。

当你想从一个Activity 跳转到另一个Activity 时，你会使用这个方法。

例如，如果你有一个MainActivity 并且你想从那里跳转到SecondActivity，你可以这样做：
java
Intent intent = new Intent(MainActivity.this, SecondActivity.class);
startActivity(intent);
Intent 是Android 中用于描述一个操作的对象，它告诉系统你想执行什么操作（例如打开一个新的Activity）。

startActivity()` 方法会接受一个Intent 对象，然后执行这个操作。

在上述代码中：
MainActivity.this 是当前Activity 的引用。

SecondActivity.class 是你想要打开的新的Activity 的类名。

注意：在调用startActivity() 之后，当前的Activity 会被加入到历史堆栈中，用户可以按返回按钮返回到这个Activity。

如果你不希望用户能够返回到原始的Activity（例如，你正在执行一个登录操作，并且用户在登录后应该被重定向到一个新的屏幕），你可以使用startActivityForResult() 方法，并在新的Activity 中使用setResult() 方法来返回结果。

Android应用程序在新的进程中启动新的Activity的方法和过程分析

前面我们在分析Activity启动过程的时候，看到同一个应用程序的Activity一般都是在同一个进程中启动，事实上，Activity也可以像Service一样在新的进程中启动，这样，一个应用程序就可以跨越好几个进程了，本文就分析一下在新的进程中启动Activity的方法和过程。

在前面Android进程间通信（IPC）机制Binder简要介绍和学习计划一文中，我们提到，在Android 系统中，每一个应用程序都是由一些Activity和Service组成的，一般Service运行在独立的进程中，而Activity有可能运行在同一个进程中，也有可能运行在不同的进程中。

在前面Android系统在新进程中启动自定义服务过程（startService）的原理分析一文中，我们已经介绍了使用Activity.startService接口来在新进程中启动Service的过程，然后又在前面Android应用程序内部启动Activity过程（startActivity）的源代码分析一文中介绍了使用Activity.startActivity接口来在原来的进程中启动Activity的过程，现在，我们就来看一下同一个Android应用程序如何在新的进程中启动新的Activity。

老规矩，我们通过例子来介绍Android应用程序在新的进程中启动新的Activity的方法以及分析其过程。

首先在Android源代码工程中创建一个Android应用程序工程，名字就称为Process吧。

关于如何获得Android源代码工程，请参考在Ubuntu上下载、编译和安装Android最新源代码一文；关于如何在Android 源代码工程中创建应用程序工程，请参考在Ubuntu上为Android系统内置Java应用程序测试Application Frameworks层的硬件服务一文。

这个应用程序工程定义了一个名为shy.luo.process的package，这个例子的源代码主要就是实现在这里了。

简单介绍Android中Activity的四种启动模式

简单介绍Android中Activity的四种启动模式
在Android中每个界⾯都是⼀个Activity，切换界⾯操作其实是多个不同Activity之间的实例化操作。

在Android中Activity的启动模式决定了Activity的启动运⾏⽅式。

Activity有四种启动模式：
1. standard，默认的启动模式，只要激活Activity，就会创建⼀个新的实例，并放⼊任务栈中，这样任务栈中可能同时有⼀个Activity的多个实例。

2. singleTop，激活Activity时，如果栈顶是这个Activity，就不会创建新的实例；如果栈顶不是这个Activity，则会创建新的实例。

3. singleTask，如果栈中存在Activity的实例，则将栈中该实例以上的其他Activity的实例移除，让该Activity的实例在栈顶；如果栈中不存在实例，则创建新的实例。

4. singleInstance，多个应⽤共享Activity的⼀个实例，不论是否是同⼀个应⽤，只要是激活该Activity，都重⽤这个实例。

可以在AndroidManifest.xml中为Activity设置启动模式，具体⽅法是设置android:launchMode属性。

有的应⽤需要在两个窗体来回跳转，如A-->B，B-->A，......，这时就需要将A和B的启动模式设置为singleTask，否则按返回键时，也将在A和B两个窗体来回跳转。

以上内容是⼩编给⼤家介绍的Android中Activity的四种启动模式，希望对⼤家有所帮助！。

详解AndroidActivity的启动流程

详解AndroidActivity的启动流程⽬录前⾔简要uncher向AMS发送启动Activity2.AMS启动Activity并通知Launcher进⼊Paused状态3.新的进程启动，ActivityThread的main函数⼊⼝4.创建Activity总结前⾔activity启动的流程分为两部分：⼀是在activity中通过startActivity(Intent intent)⽅法启动⼀个Activity；⼆是我们在桌⾯通过点击应⽤图标启动⼀个App然后显⽰Activity；第⼆种⽅式相较于第⼀种⽅式更加全⾯，所以本⽂会以第⼆种流程来分析。

简要我们⼿机的桌⾯是⼀个叫做Launcher的Activity，它罗列了⼿机中的应⽤图标，图标中包含安装apk时解析的应⽤默认启动页等信息。

在点击应⽤图标时，即将要启动的App和Launcher、AMS、Zygote所属进程不同所以涉及到Launcher与AMS，AMS与Zygote，AMS与新App这四者多次通信，才会启动⼀个App,然后再启动Activity，整体的时序图如下：接下来根据源码来梳理⼀下流程。

uncher向AMS发送启动ActivityLauncher本⾝是⼀个Activity，在⽤户点击应⽤图标时，调⽤startActivitySafely⽅法，最后调⽤到Activity.startActivity()，函数调⽤如下Launcher.javapublic boolean startActivitySafely(View v, Intent intent, ItemInfo item) {...//标记在新的栈启动intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);...startActivity(intent, optsBundle);...}Activity.java@Overridepublic void startActivity(Intent intent) {this.startActivity(intent, null);}@Overridepublic void startActivity(Intent intent, @Nullable Bundle options) {...if (options != null) {//-1为requestCode表明不需要知道是否启动成功startActivityForResult(intent, -1, options);} else {startActivityForResult(intent, -1);}}public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,@Nullable Bundle options) {...Instrumentation.ActivityResult ar =mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken,this,intent, requestCode, options);...}每个Activity都持有Instrumentation对象，通过它的execStartActivity函数来继续完成启动Activity的流程，这个函数中传⼊了mMainThread.getApplicationThread()，它获取到的是ActivityThread的内部类ApplicationThread，这是⼀个Binder对象，之后AMS通过此对象与App的通信。