一，从桌面启动应用
从桌面启动一个应用其实质也是从一个Activity中启动另一个Activity，比如官方的实例代码中：
android/platform_packages_apps_launcher
/**
* 点击桌面图标启动Intent指向的Activity
*
* @param v The view representing the clicked shortcut.
*/
public void onClick(View v) {
Object tag = v.getTag();//获取点击位置
if (tag instanceof ApplicationInfo) {//是ApplicationInfo的一个成员
// Open shortcut
final Intent intent = ((ApplicationInfo) tag).intent;
startActivitySafely(intent);//启动应用
} else if (tag instanceof FolderInfo) {
handleFolderClick((FolderInfo) tag);
}
}
void startActivitySafely(Intent intent) {
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
startActivity(intent);
} catch (ActivityNotFoundException e) {
Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
} catch (SecurityException e) {
Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
e(LOG_TAG, "Launcher does not have the permission to launch " + intent +
". Make sure to create a MAIN intent-filter for the corresponding activity " +
"or use the exported attribute for this activity.", e);
}
}二，Activity内启动Activity
因为现在几乎都是从AppCompatActivity创建Activity，所以我们从AppCompatActivity开始分析。AppCompatActivity的类继承关系如下：
我们知道，如果从自己的Activity中调用startActivity()方法，系统会在类族中从下到上依次查找，直到遇到一个startActivity()为止，所以为了方便观察，先找出各类中启动startActivity方法和startActivityForResult方法（如果类中有的话）：
AppCompatActivity中没有，它会向上查找父类FragmentActivity。
FragmentActivity中有一个startActivityForResult(Intent intent, int requestCode)，并且在此方法中又super了此方法，所以它会在执行完后继续向上查找startActivityForResult(intent, requestCode)方法并执行：
/**
* Modifies the standard behavior to allow results to be delivered to fragments.
* This imposes a restriction that requestCode be <= 0xffff.
*/
@Override
public void startActivityForResult(Intent intent, int requestCode) {
// If this was started from a Fragment we've already checked the upper 16 bits were not in
// use, and then repurposed them for the Fragment's index.
if (!mStartedActivityFromFragment) {
if (requestCode != -1) {
checkForValidRequestCode(requestCode);
}
}
super.startActivityForResult(intent, requestCode);
}FragmentActivity的直接父类是BaseFragmentActivityJB，在它的类中有一个startActivityForResult(Intent intent, int requestCode,
@Nullable Bundle options)方法，显然不是FragmentActivity中那个方法调用的，FragmentActivity会再继续向上查找startActivityForResult(intent, requestCode)，BaseFragmentActivityJB中的这个方法同样也super了startActivityForResult(intent, requestCode, options)：
@Override
public void startActivityForResult(Intent intent, int requestCode,
@Nullable Bundle options) {
// If this was started from a Fragment we've already checked the upper 16 bits were not in
// use, and then repurposed them for the Fragment's index.
if (!mStartedActivityFromFragment) {
if (requestCode != -1) {
checkForValidRequestCode(requestCode);
}
}
super.startActivityForResult(intent, requestCode, options);
}然后中间几个类就没有启动Activity的方法了，看Activity：
@Override
public void startActivity(Intent intent) {
this.startActivity(intent, null);
} @Override
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// Note we want to go through this call for compatibility with
// applications that may have overridden the method.
startActivityForResult(intent, -1);
}
} public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}因为View一般是填充到Activity中去的，如果在View类中封装的事件中需要启动Activity，会需要传入Context，这个Context一般都是所在Activity赋予，所以这种情况下也是Activity中启动Activity，所以下面判断了是不是从UI中启动：
public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
if (mParent == null) {//不是从UI中启动Activity
//实现应用检测代码的基类，内部类.ActivityResult表示返回的Activity执行的结果
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(//执行启动Activity
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
mMainThread.sendActivityResult(//主线程发送执行结果
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
if (requestCode >= 0) {
// 如果这个开始请求一个结果, 我们可以禁止让这个activity 可见，直到收到返回结果。
// 设置这个代码使activity在 onCreate(Bundle savedInstanceState) 或者onResume() 期间处于隐藏状态,避免闪烁.
// 只有在要求返回结果时才这么做，这样保证我们可以获得返回的信息，当activity结束，不管会发生什么。
mStartedActivity = true;//表示启动Activity
}
cancelInputsAndStartExitTransition(options);
// TODO Consider clearing/flushing other event sources and events for child windows.
} else {
if (options != null) {
mParent.startActivityFromChild(this, intent, requestCode, options);
} else {
// Note we want to go through this method for compatibility with
// existing applications that may have overridden it.
mParent.startActivityFromChild(this, intent, requestCode);
}
}
}在上面这个startActivityForResult中会判断是不是从界面中启动，不是则执行Instrumentation.execStartActivity，如果是则执行startActivityFromChild，Activity是UI：
public void startActivityFromChild(@NonNull Activity child, @RequiresPermission Intent intent,
int requestCode) {
startActivityFromChild(child, intent, requestCode, null);
}public void startActivityFromChild(@NonNull Activity child, @RequiresPermission Intent intent,
int requestCode, @Nullable Bundle options) {
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, child,
intent, requestCode, options);
if (ar != null) {
mMainThread.sendActivityResult(
mToken, child.mEmbeddedID, requestCode,
ar.getResultCode(), ar.getResultData());
}
cancelInputsAndStartExitTransition(options);
}startActivityFromChild中也是执行Instrumentation.execStartActivity，其有三个同名方法，一个执行的是来自Fragment，一个来自application的，还有一个是指定用户才可以调用的，这儿为第二个：
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
Uri referrer = target != null ? target.onProvideReferrer() : null;
if (referrer != null) {
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
if (mActivityMonitors != null) {//如果Activity监视器不为空
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
if (am.match(who, null, intent)) {
am.mHits++;
if (am.isBlocking()) {//如果是阻塞的，暂停状态的
return requestCode >= 0 ? am.getResult() : null;//如果有请求结果返回结果，如果没有返回null
}
break;
}
}
}
}
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess();
int result = ActivityManagerNative.getDefault()//与ActivityManagerService通信启动Activity
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}通过上面的方法可以得出，如果从我们继承自AppCompatActivit的Activity启动另一个Activity，程序执行的步骤：
结合代码可以看到从AppCompatActivity调用的startActivityForResult只是比从Activity中调用的多了以下这段代码：
//如果不是从Fragmengt启动的Activity
if (!mStartedActivityFromFragment) {
if (requestCode != -1) {//如果请求码不是-1
checkForValidRequestCode(requestCode);//检查给定的请求码是否有效
}
}来自BaseFragmentActivityEclair：
static void checkForValidRequestCode(int requestCode) {
if ((requestCode & 0xffff0000) != 0) {
throw new IllegalArgumentException("Can only use lower 16 bits for requestCode");//请求码不能超过16位
}
}三，Fragment中启动Activity
在Fragment中有启动Activity的方法，可以通过它启动Activity,但在android.app包和android.support.v4.app包两个包中都Fragment类，这时就得分情况了，使用哪个包中的就导入哪个包中的Fragment。
导入android.app.Fragment
调用android.app.Fragment中的startActivity或startActivityForResult：
/**
* Call {@link Activity#startActivity(Intent)} from the fragment's
* containing Activity.
*/
public void startActivity(Intent intent) {
startActivity(intent, null);
}
/**
* Call {@link Activity#startActivity(Intent, Bundle)} from the fragment's
* containing Activity.
*/
public void startActivity(Intent intent, @Nullable Bundle options) {
if (mHost == null) {
throw new IllegalStateException("Fragment " + this + " not attached to Activity");
}
mHost.onStartActivityFromFragment(this /*fragment*/, intent, -1, options);
}/**
* Call {@link Activity#startActivityForResult(Intent, int)} from the fragment's
* containing Activity.
*/
public void startActivityForResult(Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}
/**
* Call {@link Activity#startActivityForResult(Intent, int, Bundle)} from the fragment's
* containing Activity.
*/
public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
if (mHost == null) {
throw new IllegalStateException("Fragment " + this + " not attached to Activity");
}
mHost.onStartActivityFromFragment(this /*fragment*/, intent, requestCode, options);
}可以看出startActivity和startActivityForResult调用的都是FragmentHostCallback.onStartActivityFromFragment，FragmentHostCallback是抽象类，Activity类中的内部类HostCallbacks是它的实现类：
class HostCallbacks extends FragmentHostCallback<Activity> {
...
@Override
public void onStartActivityFromFragment(Fragment fragment, Intent intent, int requestCode,
Bundle options) {
Activity.this.startActivityFromFragment(fragment, intent, requestCode, options);
}
...
}Activity.startActivityFromFragment：
public void startActivityFromFragment(@NonNull Fragment fragment,
@RequiresPermission Intent intent, int requestCode) {
startActivityFromFragment(fragment, intent, requestCode, null);
}
public void startActivityFromFragment(@NonNull Fragment fragment,
@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
startActivityForResult(fragment.mWho, intent, requestCode, options);
}它又调用Activity类的隐藏方法startActivityForResult：
/**
* @hide
*/
@Override
public void startActivityForResult(
String who, Intent intent, int requestCode, @Nullable Bundle options) {
Uri referrer = onProvideReferrer();
if (referrer != null) {
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, who,
intent, requestCode, options);
if (ar != null) {
mMainThread.sendActivityResult(
mToken, who, requestCode,
ar.getResultCode(), ar.getResultData());
}
cancelInputsAndStartExitTransition(options);
}
然后最终调用Instrumentation.execStartActivity，Fragment使用的这个方法和Activity使用的同名方法的第4个参数不同，虽然含义相同：
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, String target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
if (am.match(who, null, intent)) {
am.mHits++;
if (am.isBlocking()) {
return requestCode >= 0 ? am.getResult() : null;
}
break;
}
}
}
}
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess();
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
流程可以简洁表示如下：
相关类图：
这儿使用了MVC架构，
；FragmentHostCallback类组为模型模块；Activity作为视图模块。
MVC架构模式
方便理解，特意百度图片：
模型（Model） “数据模型”（Model）用于封装与应用程序的业务逻辑相关的数据以及对数据的处理方法。“模型”有对数据直接访问的权力，例如对数据库的访问。“模型”不依赖“视图”和“控制器”，也就是说，模型不关心它会被如何显示或是如何被操作。但是模型中数据的变化一般会通过一种刷新机制被公布。为了实现这种机制，那些用于监视此模型的视图必须事先在此模型上注册，从而，视图可以了解在数据模型上发生的改变。（比较：观察者模式（软件设计模式））
这儿是把Fragment当作数据，FragmentHostCallback类组对Fragment进行业务处理的封装，其子类HostCallbacks是Activity的内部类，并对Activity中的一些方法进行调用（放在Activity中方便外部调用）：
class HostCallbacks extends FragmentHostCallback<Activity> {
public HostCallbacks() {
super(Activity.this /*activity*/);
}
@Override
public void onDump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
Activity.this.dump(prefix, fd, writer, args);
}
FragmentHostCallback(Activity activity) {
this(activity, activity /*context*/, activity.mHandler, 0 /*windowAnimations*/);
}
@Override
public void onStartActivityFromFragment(Fragment fragment, Intent intent, int requestCode,
Bundle options) {
Activity.this.startActivityFromFragment(fragment, intent, requestCode, options);
}
...
}视图（View） 视图层能够实现数据有目的的显示（理论上，这不是必需的）。在视图中一般没有程序上的逻辑。为了实现视图上的刷新功能，视图需要访问它监视的数据模型（Model），因此应该事先在它监视的数据模型那里注册。
Activity类此时在这儿充当视图层，如上在HostCallbacks的构造器中设置了模型关联的activity及上下文环境activity。Activity对控制器FragmentController进行引用，并进行一些方法调用：
final FragmentController mFragments = FragmentController.createController(new HostCallbacks());
...
mFragments.dispatchResume();
mFragments.execPendingActions();控制器（Controller） 控制器起到不同层面间的组织作用，用于控制应用程序的流程。它处理事件并作出响应。“事件”包括用户的行为和数据模型上的改变。
FragmentController和FragmentManager共同组成了控制器模块，FragmentController通过FragmentHostCallback.getFragmentManagerImpl()获得FragmentManager，然后共同对FragmentHostCallback进行控制，间接对Activity发挥作用：
/**意思是与FragmentManager一块为fragment宿主提供一个关键点，响应宿主管理fragment的生命周期。
* Provides integration points with a {@link FragmentManager} for a fragment host.
* <p>
* It is the responsibility of the host to take care of the Fragment's lifecycle.
* The methods provided by {@link FragmentController} are for that purpose.
*/
public class FragmentController {
private final FragmentHostCallback<?> mHost;
/**
* Returns a {@link FragmentController}.
*/
public static final FragmentController createController(FragmentHostCallback<?> callbacks) {
return new FragmentController(callbacks);
}
private FragmentController(FragmentHostCallback<?> callbacks) {
mHost = callbacks;
}MVC模式根据情景不同，可能会有好几个嵌套，一个类会充当好几个角色。现在应用中比较流行切某些场合下更好的是MVP模式，所以了解即可。
导入android.support.v4.app.Fragment
使用android.support.v4.app.Fragment会和使用android.app.Fragment之间有稍微的差异。
android.support.v4.app.Fragment启动Activity的方法和android.app.Fragment中的代码相同，这里略。
调用的都是FragmentHostCallback.onStartActivityFromFragment，这儿的FragmentHostCallback也是抽象类，但和那个不是一个类，虽然类名相同，但所在不是同一个包（这部分的Fragment相关类在android.support.v4.app包中），它的实现类是FragmentActivity类中的内部类HostCallbacks：
@Override
public void onStartActivityFromFragment(Fragment fragment, Intent intent, int requestCode) {
FragmentActivity.this.startActivityFromFragment(fragment, intent, requestCode);
}
@Override
public void onStartActivityFromFragment(
Fragment fragment, Intent intent, int requestCode, @Nullable Bundle options) {
FragmentActivity.this.startActivityFromFragment(fragment, intent, requestCode, options);
}都是调用FragmentActivity.startActivityFromFragment（参数不同）：
/**
* Called by Fragment.startActivityForResult() to implement its behavior.
*/
public void startActivityFromFragment(Fragment fragment, Intent intent,
int requestCode) {
startActivityFromFragment(fragment, intent, requestCode, null);
}
/**
* Called by Fragment.startActivityForResult() to implement its behavior.
*/
public void startActivityFromFragment(Fragment fragment, Intent intent,
int requestCode, @Nullable Bundle options) {
mStartedActivityFromFragment = true;
try {
if (requestCode == -1) {
ActivityCompat.startActivityForResult(this, intent, -1, options);
return;
}
checkForValidRequestCode(requestCode);
int requestIndex = allocateRequestIndex(fragment);
ActivityCompat.startActivityForResult(
this, intent, ((requestIndex + 1) << 16) + (requestCode & 0xffff), options);
} finally {
mStartedActivityFromFragment = false;
}
}ActivityCompat.startActivityForResult：
public static void startActivityForResult(Activity activity, Intent intent, int requestCode,
@Nullable Bundle options) {
if (Build.VERSION.SDK_INT >= 16) {
ActivityCompatJB.startActivityForResult(activity, intent, requestCode, options);
} else {
activity.startActivityForResult(intent, requestCode);
}
}如果版本大于等于16，调用ActivityCompatJB.startActivityForResult，否则调用宿主activity的startActivityForResult(intent, requestCode)，ActivityCompatJB.startActivityForResult：
public static void startActivityForResult(Activity activity, Intent intent, int requestCode, Bundle options) {
activity.startActivityForResult(intent, requestCode, options);
}宿主activity即是FragmentActivity或其子类，调用的是FragmentActivity.startActivityForResult。
@Override
public void startActivityForResult(Intent intent, int requestCode) {
// If this was started from a Fragment we've already checked the upper 16 bits were not in
// use, and then repurposed them for the Fragment's index.
if (!mStartedActivityFromFragment) {
if (requestCode != -1) {
checkForValidRequestCode(requestCode);
}
}
super.startActivityForResult(intent, requestCode);
} 后面略，请参考前面Activity中启动Activity.相关类关系和前面Fragment类关系相似，也不重复了。
附：app包中的fragment和v4包中的fragment的相关使用
1，app包中的fragment，因为这个是在3.0之后才有的，支持3.0以后的版本，如果需要支持更低版本，需要使用v4包中的fragment。’这两个类功能几乎一样，都是可以使用标签，区别是导入包时的包名是不一样的。对应的方法名类似，不尽相同，实现过程也有点差异，所以如果用混了会报错。
2，因为现在大部分都是基于AppCompatActivity使用Fragment，所以在Fragment中启动Activity如果要求返回结果，如果导入的是app包中的fragment，则有两种实现方案：
第一种：调用Fragment的startActivityForResult方法，然后在Fragment的onActivityResult的方法中处理返回的请求。
第二种：在Fragment中通过getActivity()方法获取到Fragment所在的FragmentActivity对象，调用activity对象的startActivityForResult方法启动Activity，然后在FragmentActivity的onActivityResult的方法中处理返回的请求。
四，其它组件中启动Activity
其他组件还可以启动Activity的有Service和Broadcast Receiver，他们都是脱Activity运行的。
在Service中可以直接调用startActivity（因为Service是Context的一个子类），Broadcast Receiver调用Context.startActivity，此时它们调用的方法实现都是ContextImpl.startActivity：
@Override
public void startActivity(Intent intent) {
warnIfCallingFromSystemProcess();
startActivity(intent, null);
}
@Override
public void startActivity(Intent intent, Bundle options) {
warnIfCallingFromSystemProcess();
if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
throw new AndroidRuntimeException(
"Calling startActivity() from outside of an Activity "
+ " context requires the FLAG_ACTIVITY_NEW_TASK flag."
+ " Is this really what you want?");
}
mMainThread.getInstrumentation().execStartActivity(
getOuterContext(), mMainThread.getApplicationThread(), null,
(Activity) null, intent, -1, options);
}可以看到这儿有个判断intent中是否有个Intent.FLAG_ACTIVITY_NEW_TASK标志，如果没有就报错。在service中启动示例：
Intent intent=new Intent(getApplicationContext(),AnotherActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);Broadcast Receiver同理。
五，最后附上一张图
注：这里都是用Intent传递信息，还可以使用PendingIntent。