关于Activity的一些总结

最新推荐文章于 2019-04-20 20:49:29 发布

落凤坡369

最新推荐文章于 2019-04-20 20:49:29 发布

阅读量430

点赞数 1

本文链接：https://blog.csdn.net/zjw369144735/article/details/84969041

版权

一:Activity的生命周期

二:Activity的启动模式

Activity上有Dialog的时候按Home键时的生命周期
两个Activity跳转的生命周期，如果一个Activity跳转另一个Activity再按下Home键在回到Activity的生命周期是什么样的
Activity的生命周期，finish调用后其他生命周期还会走么？
ActivityA跳转ActivityB然后B按back返回A，各自的生命周期顺序，A与B均不透明
有什么工具可以看到Activity栈信息么？

三:Activity中项目中栈管理

四:Activity的四种状态

五:Activity window view 三者的关系

六:Activity之间传递数据

android中Bundle和Intent的区别

七:Activity状态保存与恢复

八:Activity的启动过程(不是生命周期)

一:Activity的生命周期

1.onCreate()

当活动第一次启动的时候，触发该方法，可以在此时完成活动的初始化工作。 onCreate 方法有一个参数，该参数可以为空（ null ），也可以是之前调用 onSaveInstanceState （）方法保存的状态信息。

2.onStart()

该方法的触发表示所属活动将被展现给用户，“用户可见不可交互”的状态。

3.onResume()

当一个活动和用户发生交互的时候，触发该方法(在Activity栈系统通过栈的方式管理这些Activity，即当前Activity在栈的最上端，运行完弹出栈，则回到上一个Activity)。

4.onPause()

当一个正在前台运行的活动因为其他的活动需要前台运行而转入后台运行的时候，触发该方法。这时候需要将活动的状态持久化,保存起来，比如正在编辑的数据库记录等。

5.onStop()

当一个活动不再需要展示给用户的时候，触发该方法。如果内存紧张，系统会直接结束这个活动，而不会触发 onStop 方法。所以保存状态信息是应该在onPause时做，而不是onStop时做。活动如果没有在前台运行，都将被停止或者Linux管理进程为了给新的活动预留足够的存储空间而随时结束这些活动。因此对于开发者来说，在设计应用程序的时候，必须时刻牢记这一原则。在一些情况下，onPause方法或许是活动触发的最后的方法，因此开发者需要在这个时候保存需要保存的信息

6.onRestart()

当处于停止状态的活动需要再次展现给用户的时候，触发该方法。

7.onDestroy()

当活动销毁的时候，触发该方法。和 onStop 方法一样，如果内存紧张，系统会直接结束这个活动而不会触发该方法。

二:Activity的启动模式

启动模式的介绍: 启动模式简单地说就是Activity启动时的策略，在AndroidManifest.xml中的标签的android:launchMode属性设置

启动模式有4种，分别为standard、singleTop、singleTask、singleInstance,(默认是standard模式)

任务栈: 每个应用都有一个任务栈，是用来存放Activity的，功能类似于函数调用的栈，先后顺序代表了Activity的出现顺序

栈和队列: 栈:后进先出; 队列:先进先出

1.standard 标准模式

每次激活Activity时都会创建Activity，并放入任务栈中

2.singleTop 模式(消息推送打开的界面, 复用栈顶)

如果在任务的栈顶正好存在该Activity的实例，就重用该实例，否者就会创建新的实例并放入栈顶(即使栈中已经存在该 Activity 实例，只要不在栈顶，都会创建实例),重用该实例，是先调用onNewIntent方法，再调用onResume方法

3.singleTask模式

如果在栈中已经有该Activity的实例，就重用该实例(会调用实例的onNewIntent())。重用时，会让该实例回到栈顶，因此在它上面的实例将会被移除栈(执行clearTop策略)。如果栈中不存在该实例，将会创建新的实例放入栈中

4.singleInstance模式(单独占用一个栈, 呼叫来电, 全局唯一性)

单一实例模式，整个手机操作系统里面只有一个实例存在。不同的应用去打开这个activity 共享公用的同一个activity。他会运行在自己单独，独立的任务栈里面，并且任务栈里面只有他一个实例存在。应用场景：呼叫来电界面。这种模式的使用情况比较罕见，在Launcher中可能使用。或者你确定你需要使Activity只有一个实例

问题一:Activity上有Dialog的时候按Home键时的生命周期

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.d("MainActivity-->", "onCreate")
        button1?.setOnClickListener {
            var intent = Intent(this@Main2Activity, SecondActivity::class.java)
            startActivity(intent)
        }
        button2?.setOnClickListener {
            val dialog = AlertDialog.Builder(this@Main2Activity)
            dialog.setIcon(R.mipmap.ic_launcher)
            dialog.setTitle("我是Activity内一个dialog")
            dialog.setMessage("你要选哪个?")

            dialog.setPositiveButton("确定") { dialog, _ ->
                Toast.makeText(this@Main2Activity, "点击了确定", Toast.LENGTH_LONG).show()
                dialog.dismiss()
            }
            dialog.setNegativeButton("取消") { dialog, _ ->
                Toast.makeText(this@Main2Activity, "点击了取消", Toast.LENGTH_LONG).show()
                dialog.dismiss()
            }
            dialog.show()

        }
    }
}

经测试:

首先会执行activity的oncreate->onstart->onresume,点击打开和dismiss()dialog ,Activity的生命周期没有发生变化

D/MainActivity-->: onCreate
D/MainActivity-->: onStart
D/MainActivity-->: onResume

Dialog与 DialogFragment 都不会出发activity的生命周期变动。
也就是说，Dialog的show与dismiss不会引发activity的onPause()和onResume的执行。

当展示dialog的同时按下home键:

D/MainActivity-->: onPause
D/MainActivity-->: onStop

重新打开应用:

D/MainActivity-->: onRestart
D/MainActivity-->: onStart
D/MainActivity-->: onResume

问题二:两个Activity跳转的生命周期，如果一个Activity跳转另一个Activity再按下Home键在回到Activity的生命周期是什么样的

打开mainActivity:

D/MainActivity-->: onCreate
D/MainActivity-->: onStart
D/MainActivity-->: onResume

点击button打开SecondSctivity():

首先执行MainActivity的onPause(),可以在这个方法中关闭一些MainActivity中的操作,如关闭音乐等,其次调用SecondActivity的oncreate->onstart->onresume,如果当前SecondActivity不为透明的,则调用MainActivity的onStop,如果SecondActivity是透明的则不调用mainActivity的onstop(),说明MainActivity可见但是不可交互

D/MainActivity-->: onPause
D/SecondActivity-->: onStart
D/SecondActivity-->: onStart
D/SecondActivity-->: onResume
D/MainActivity-->: onStop

此时按下Home键:

D/SecondActivity-->: onPause
D/SecondActivity-->: onStop

从新打开:

D/SecondActivity-->: onRestart
D/SecondActivity-->: onStart
D/SecondActivity-->: onResume

问题三:Activity的生命周期，finish调用后其他生命周期还会走么？

点击button,直接调用finish()

D/MainActivity-->: onPause
D/MainActivity-->: onStop
D/MainActivity-->: onDestroy

其他的生命周期还是会走的,和点击back退出应用一样

问题四:ActivityA跳转ActivityB然后B按back返回A，各自的生命周期顺序，A与B均不透明

A跳到B:A(onPause())->B(oncreate(),onstart(),onresume())->A(onStop)

点击back:B(onPause())->A(onRestart(),onstart(),onResume())->B(onStrop(),ondestroy())

 //main 打开
 D/MainActivity-->: onCreate
 D/MainActivity-->: onStart
 D/MainActivity-->: onResume
 //跳转到B
 D/MainActivity-->: onPause
 D/SecondActivity-->: onStart
 D/SecondActivity-->: onStart
 D/SecondActivity-->: onResume
 D/MainActivity-->: onStop
 //点击back
 D/SecondActivity-->: onPause
 D/MainActivity-->: onRestart
 D/MainActivity-->: onStart
 D/MainActivity-->: onResume
 D/SecondActivity-->: onStop
 D/SecondActivity-->: onDestroy

问题五:有什么工具可以看到Activity栈信息么？

可以用adb命令: 在android studio 中 Terminal中输入 adb shell dumpsys activity activities

可看到栈信息

F:\android_project\InterviewDemo>adb shell dumpsys activity activities
ACTIVITY MANAGER ACTIVITIES (dumpsys activity activities)
Display #0 (activities from top to bottom):
  Stack #1:
    Task id #5998
    * TaskRecord{3ce195ae #5998 A=com.app.interview U=0 sz=2}
      userId=0 effectiveUid=u0a437 mCallingUid=2000 mCallingPackage=null
 sourceIntent=Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.app.interview/.Main2Activity }
      affinity=com.app.interview
      intent={act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.app.interview/.Main2Activity}
      realActivity=com.app.interview/.Main2Activity
      autoRemoveRecents=false isPersistable=true numFullscreen=2 taskType=0 mTaskToReturnTo=1
      rootWasReset=false mNeverRelinquishIdentity=true mReuseTask=false
      Activities=[ActivityRecord{3698c575 u0 com.app.interview/.Main2Activity t5998}, ActivityRecord{1b45470d u0 com.app.interview/.SecondActivity t5998}]
      askedCompatMode=false inRecents=true isAvailable=true

三:Activity中项目中栈管理

class AppManager private constructor() {
    private var activityStack: Stack<Activity> = Stack<Activity>()

    companion object {
        val instant: AppManager by lazy { AppManager() }
    }

    /**
     * 添加Activity到堆栈
     */
    fun addActivity(activity: Activity) {
        activityStack.add(activity)
    }

    /**
     * 获取当前Activity（堆栈中最后一个压入的）
     */
    fun currentActivity(): Activity {
        return activityStack.lastElement()
    }

    /**
     * 结束当前Activity（堆栈中最后一个压入的）
     */
    fun finishActivity() {
        val activity = activityStack.lastElement()
        finishActivity(activity)
    }

    /**
     * 结束指定的Activity
     */
    fun finishActivity(activity: Activity?) {
        var activity = activity
        if (activity != null) {
            activityStack.remove(activity)
            activity.finish()
            activity = null
        }
    }

    /**
     * 结束指定类名的Activity
     */
    fun finishActivity(cls: Class<*>) {
        for (activity in activityStack) {
            if (activity.javaClass == cls) {
                finishActivity(activity)
            }
        }
    }

    /**
     * 结束所有Activity
     */
    fun finishAllActivity() {
        var i = 0
        val size = activityStack.size
        while (i < size) {
            if (null != activityStack[i]) {
                activityStack[i].finish()
            }
            i++
        }
        activityStack.clear()
    }

    /**
     * 退出应用程序
     */
    fun AppExit(context: Context) {
        try {
            finishAllActivity()
            val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
            activityManager.restartPackage(context.packageName)
            System.exit(0)
        } catch (e: Exception) {
            e.printStackTrace()
        }

    }
}

四:Activity的四种状态

1.actived /running 处于栈顶，获取焦点

2.pasued ：启动一个dialogActivity 热然可以显示但是没有焦点，window保留他的状态

3.stoped：完全给覆盖

4.killed：被销毁

五:Activity window view 三者的关系

详细流程: https://blog.csdn.net/freekiteyu/article/details/79408969

这里只写下自己的理解和总结

从activity的seContentView()方法()

public void setContentView(View view) {
        getWindow().setContentView(view);
        initWindowDecorActionBar();
    }

getWindow 返回的是window子类PhoneWindow

public Window getWindow() {
        return mWindow;
}
//在Activity的attach()方法中
mWindow = new PhoneWindow(this, window, activityConfigCallback);

再来看PhoneWindow的setcontentview()

@Override
    public void setContentView(View view, ViewGroup.LayoutParams params) {
        if (mContentParent = null) {
            installDecor();
        }
    }

private void installDecor() {
        if (mDecor == null){
            mDecor = generateDecor();
        }
    }

在generateDecor()里直接new DecorView()的对像, DecorView是PhoneWindow的内部类,他继承FrameLayout;

contentView就是我界面展示的内容,

简单总结:假如Activity相当于一个窗户的框架,window就是当前框架里面的玻璃,DecorView相当于窗户玻璃上的窗花

六:Activity之间传递数据

1.使用intent传值

MainActivity中

var intent = Intent(this@Main2Activity, SecondActivity::class.java)
            intent.putExtra("字符串","张三")
            intent.putExtra("int",10)
            startActivity(intent)

SecondActivity中

var intent = intent
        val stringExtra = intent.getStringExtra("字符串")
        val intExtra = intent.getIntExtra("int", 0)
        Log.d("SecondActivity-->", "字符串:${stringExtra} int数:${intExtra}")

D/SecondActivity-->: 字符串:张三 int数:10

2.使用bundle

var intent = Intent(this@Main2Activity, SecondActivity::class.java)
            var bundle = Bundle()
            bundle.putBoolean("boolean",true)
            bundle.putString("字符串","李四")
            intent.putExtra("bundle",bundle)
            startActivity(intent)

var intent = intent
        val bundleExtra = intent.getBundleExtra("bundle")
        val stringExtra = bundleExtra.getString("字符串")
        val booleanExtra = bundleExtra.getBoolean("boolean", false)
        Log.d("SecondActivity-->", "字符串:$stringExtra boolean类型:$booleanExtra")

2.startActivityForResult()的方式

mainActivity:

 var intent = Intent(this@Main2Activity, SecondActivity::class.java)
            var bundle = Bundle()
            bundle.putBoolean("boolean",true)
            bundle.putString("字符串","李四")
            intent.putExtra("bundle",bundle)
            startActivityForResult(intent,0) //0是请求码

SecondActivity:

var intent = Intent(this@SecondActivity, Main2Activity::class.java)
            var bundle = Bundle()
            bundle.putString("字符串", "王五")
            intent.putExtras(bundle)
            this.setResult(1, intent)  //1是返回码
            this.finish()

mainActivity中重写onActivityResult()

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        when(requestCode){
            0-> if (resultCode == 1)  {Log.d("mainActivity-->",""+data?.extras?.getString("字符串"))}
        }
    }

问题一:android中Bundle和Intent的区别

Intent不仅可用于应用程序之间，也可用于应用程序内部的Activity/Service之间的交互。Android中与Intent相关的还有Action/Category及Intent Filter等，另外还有用于广播的Intent

Bundle 也可存取数据把数据封装下,通过intent.putExtras(bundle) 或者 intent.putExtra("keyname",bundle)

看intent.putExtra("key",value)方法他里面也创建了一个bundle去存取数据

 public @NonNull Intent putExtra(String name, String value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putString(name, value);
        return this;
    }

 public int getIntExtra(String name, int defaultValue) {
        return mExtras == null ? defaultValue :
            mExtras.getInt(name, defaultValue);
    }

七:Activity状态保存与恢复

Activity的状态通常情况下系统会自动保存的，只有当我们需要保存额外的数据时才需要使用到这样的功能。

通常情况：调用onPause()和onStop()方法后的activity实例仍然存在于内存中, activity的所有信息和状态数据不会消失, 当activity重新回到前台之后, 所有的改变都会得到保留。

异常情况：但是当系统内存不足时, 调用onPause()和onStop()方法后的activity可能会被系统摧毁, 此时内存中就不会存有该activity的实例对象了。如果之后这个activity重新回到前台, 之前所作的改变就会消失。

为了避免数据消失：我们可以覆写onSaveInstanceState()方法。onSaveInstanceState()方法接受一个Bundle类型的参数, 开发者可以将状态数据存储到这个Bundle对象中, 这样即使activity被系统摧毁, 当用户重新启动这个activity而调用它的onCreate()方法时, 上述的Bundle对象会作为实参传递给onCreate()方法, 开发者可以从Bundle对象中取出保存的数据, 然后利用这些数据将activity恢复到被摧毁之前的状态。

class SaveActivity : AppCompatActivity() {
    var temp: String? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_save)
        val string = savedInstanceState?.getString("tempkey")
        if (!TextUtils.isEmpty(string)) {
            temp = string
        }
    }

    override fun onResume() {
        super.onResume()
        temp = "张三"
    }

    override fun onSaveInstanceState(outState: Bundle?) {
        super.onSaveInstanceState(outState)
        outState?.putString("tempkey", temp)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
        super.onRestoreInstanceState(savedInstanceState)
    }
}

八:Activity的启动过程(不是生命周期)

方式有四种

1.点击桌面图标进入

2.双击Home键进入任务管理器中点击应用进入

3.startActivity

4.A->(打开)B,B点击back,跳到A

具体详情请看->https://www.cnblogs.com/gne-hwz/p/6758308.html

最后都会到Activity的StartActivity()中

这里不做具体细节的分析,只走下流程

  @Override
    public void startActivity(Intent intent) {
      //调用重载方法
        this.startActivity(intent, null);
    }

 /*其实Activity$startActivity有几个其他重载的方法，
    但是最终都会执行到Activity$startActivityForResult方法。
    如果是调用startActivity(intent)启动Activity，
    那么requestCode参数则传入-1，表示当前Activity启动一个新的Activity后，
    不需要获取新的Activity返回来的数据。*/

@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);
        }
    }

 /*
1.mParent指的是ActivityGroup，可以在一个界面里嵌套多个Activity。随着版本的升级，在API13以后就 
   废弃掉了。所有mParent == null,则进入if语句内
2.mMainThread是一个ActivityThread对象，mMainThread.getApplicationThread()返回的是一个 
  ApplicationThread对象，ApplicationThread是ActivityThread的内部类。ApplicationThread 
  extends ApplicationThreadNative.
ApplicationThreadNative extends Binder implements IActivityManager 实际上就是Ams的代理类*/


public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
        if (mParent == null) {
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                // If this start is requesting a result, we can avoid making
                // the activity visible until the result is received.  Setting
                // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                // activity hidden during this time, to avoid flickering.
                // This can only be done when a result is requested because
                // that guarantees we will get information back when the
                // activity is finished, no matter what happens to it.
                mStartedActivity = true;
            }

            final View decor = mWindow != null ? mWindow.peekDecorView() : null;
            if (decor != null) {
                decor.cancelPendingInputEvents();
            }
            // 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);
            }
        }
        if (options != null && !isTopOfTask()) {
            mActivityTransitionState.startExitOutTransition(this, options);
        }
    }

 public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Fragment 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();
            /**
                mMainThread是一个ActivityThread对象，mMainThread.getApplicationThread()返 
                回的是一个ApplicationThread对象，ApplicationThread是ActivityThread的内部类
              
                ActivityManagerNative extends Binder implements IActivityManager
             */
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mWho : null,
                        requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
        }
        return null;
    }

ActivityManagerNative.getDefault()

 static public IActivityManager getDefault() {
        return gDefault.get();
    }

gDefault是一个单利类,里面有个IActivityManager只能加载一次

ActivityManagerProxy代理类实现了IActivityManager,里面有startActivity的方法,实际上是通过代理,底层通过binder,调用了Amw的startActivity()

因此启动Activity的操作就交给了系统服务ActivityManagerService来处理了。


  private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
        protected IActivityManager create() {
            IBinder b = ServiceManager.getService("activity");
            if (false) {
                Log.v("ActivityManager", "default service binder = " + b);
            }
            IActivityManager am = asInterface(b);
            if (false) {
                Log.v("ActivityManager", "default service = " + am);
            }
            return am;
        }
    };
}

class ActivityManagerProxy implements IActivityManager
{
    public ActivityManagerProxy(IBinder remote)
    {
        mRemote = remote;
    }

    public IBinder asBinder()
    {
        return mRemote;
    }

    public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
            String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
        data.writeString(callingPackage);
        intent.writeToParcel(data, 0);
        data.writeString(resolvedType);
        data.writeStrongBinder(resultTo);
        data.writeString(resultWho);
        data.writeInt(requestCode);
        data.writeInt(startFlags);
        if (profilerInfo != null) {
            data.writeInt(1);
            profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        } else {
            data.writeInt(0);
        }
        if (options != null) {
            data.writeInt(1);
            options.writeToParcel(data, 0);
        } else {
            data.writeInt(0);
        }
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
        reply.readException();
        int result = reply.readInt();
        reply.recycle();
        data.recycle();
        return result;
    }

启动Activity的操作交给ActivityManagerService处理

 @Override
    public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }

继续看startActivityuser()



    @Override
    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
        enforceNotIsolatedCaller("startActivity");
        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
                userId, false, ALLOW_FULL_ONLY, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, bOptions, false, userId, null, null,
                "startActivityAsUser");
    }

ActivityStarter.startActivitymayWait()

final int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, Intent intent, String resolvedType,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, WaitResult outResult,
            Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,
            IActivityContainer iContainer, TaskRecord inTask, String reason) {
	    
	  

	    int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
                    aInfo, rInfo, voiceSession, voiceInteractor,
                    resultTo, resultWho, requestCode, callingPid,
                    callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                    options, ignoreTargetSecurity, componentSpecified, outRecord, container,
                    inTask, reason);

	       
}

int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
            ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
            ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
            TaskRecord inTask, String reason) {
	    
	

	    mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
                aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
                callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
                container, inTask);
	
}


       

private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
            ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
            ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
            TaskRecord inTask) {

	

	doPendingActivityLaunchesLocked(false);

	
}


final void doPendingActivityLaunchesLocked(boolean doResume) {
	

                startActivity(pal.r, pal.sourceRecord, null, null, pal.startFlags, resume, null,
                        null, null /*outRecords*/);

	
}    


   

private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity) {
   
            result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, doResume, options, inTask, outActivity);
       
} 



 // Note: This method should only be called from {@link startActivity}.
    private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity) {
	

	mSupervisor.resumeFocusedStackTopActivityLocked();
	
}

  mFocusedStack是一个ActivityStack对象；
       ActivityStack源码如下：
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        if (mStackSupervisor.inResumeTopActivity) {
	

	result = resumeTopActivityInnerLocked(prev, options);


}



private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
	

	mStackSupervisor.startSpecificActivityLocked(next, true, true);

	

}
       mSupervisor是一个ActivityStackSupervisor对象；
       
       查看ActivityStackSupervisor源码如下：
void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {


	realStartActivityLocked(r, app, andResume, checkConfig);

	

}



final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
	

	app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info,
                    // TODO: Have this take the merged configuration instead of separate global and
                    // override configs.
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), r.compat,
                    r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                    r.persistentState, results, newIntents, !andResume,
                    mService.isNextTransitionForward(), profilerInfo);

	 
}
       变量app是一个ProcessRecord对象，它的成员变量thread是IApplicationThread类型，因此app.thread是一个IApplicationThread的代理对象。
       前面介绍ApplicationThread继承了IApplicationThread.Stub，并提出ApplicationThread重写接口IApplicationThread的抽象方法在哪里被调用。有意思的是，app.thread调用scheduleLaunchActivity方法，通过Binder机制，会使ApplicationThread$scheduleLaunchActivity方法被调用。
       于是，基于Binder机制，实现了一次进程间的通信，将启动Activity的操作交给了ApplicationThread类。
同时,ApplicationThread是activityThread的内部类,直接调用ActivityThread的内部类的scheduleLaunchActivity()方法

 public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
                ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,
                String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state,
                PersistableBundle persistentState, List<ResultInfo> pendingResults,
                List<ReferrerIntent> pendingNewIntents, boolean notResumed, boolean isForward,
                ProfilerInfo profilerInfo) {

            updateProcessState(procState, false);

            ActivityClientRecord r = new ActivityClientRecord();

            r.token = token;
            r.ident = ident;
            r.intent = intent;
            r.referrer = referrer;
            r.voiceInteractor = voiceInteractor;
            r.activityInfo = info;
            r.compatInfo = compatInfo;
            r.state = state;
            r.persistentState = persistentState;

            r.pendingResults = pendingResults;
            r.pendingIntents = pendingNewIntents;

            r.startsNotResumed = notResumed;
            r.isForward = isForward;

            r.profilerInfo = profilerInfo;

            updatePendingConfiguration(curConfig);

            sendMessage(H.LAUNCH_ACTIVITY, r);
        }

H是一个Handler

 private class H extends Handler {
        public static final int LAUNCH_ACTIVITY         = 100;
       ......
        String codeToString(int code) {
            if (DEBUG_MESSAGES) {
                switch (code) {
                    case LAUNCH_ACTIVITY: return "LAUNCH_ACTIVITY";
                    case PAUSE_ACTIVITY: return "PAUSE_ACTIVITY";
                    ...
                   
                }
            }
            return Integer.toString(code);
        }
        public void handleMessage(Message msg) {
            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
            switch (msg.what) {
                case LAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;
                ...

看handleLaunchActivity()

 private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // If we are getting ready to gc after going to the background, well
        // we are back active so skip it.
        unscheduleGcIdler();
        mSomeActivitiesChanged = true;

        if (r.profilerInfo != null) {
            mProfiler.setProfiler(r.profilerInfo);
            mProfiler.startProfiling();
        }

        // Make sure we are running with the most recent config.
        handleConfigurationChanged(null, null);

        if (localLOGV) Slog.v(
            TAG, "Handling launch of " + r);

        // Initialize before creating the activity
        WindowManagerGlobal.initialize();

        //开启Activity的方法
        Activity a = performLaunchActivity(r, customIntent);

        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            Bundle oldState = r.state;
            //onREsume的方法
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed);

            if (!r.activity.mFinished && r.startsNotResumed) {
                // The activity manager actually wants this one to start out
                // paused, because it needs to be visible but isn't in the
                // foreground.  We accomplish this by going through the
                // normal startup (because activities expect to go through
                // onResume() the first time they run, before their window
                // is displayed), and then pausing it.  However, in this case
                // we do -not- need to do the full pause cycle (of freezing
                // and such) because the activity manager assumes it can just
                // retain the current state it has.
                try {



 调用performLaunchActivity方法启动Activity；
       若a不为空，则调用handleResumeActivity方法，内部会调用Activity$onResume方法。具体的代码流程还是比较好跟的，由于不是本篇的重点，有兴趣的哥们可以自己去研究。
       当a为空，也就是创建Activity的实例出错了，走else语句。ActivityManagerNative.getDefault()前面已经分析过了，返回IActivityManager的代理对象，调用该代理对象的方法，会向系统服务ActivityManagerService发送请求，基于Binder机制，最终会调用ActivityManagerService$finishActivity方法。
       也就是说，当创建Activity实例出错后，停止启动Activity的具体操作交给ActivityManagerService来处理。

看 performLaunchActivity()

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }

        ComponentName component = r.intent.getComponent();
        if (component == null) {
            component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
            r.intent.setComponent(component);
        }

        if (r.activityInfo.targetActivity != null) {
            component = new ComponentName(r.activityInfo.packageName,
                    r.activityInfo.targetActivity);
        }

        Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
           //通过类加载器创建activity实例
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to instantiate activity " + component
                    + ": " + e.toString(), e);
            }
        }
        //创建application
        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

            if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
            if (localLOGV) Slog.v(
                    TAG, r + ": app=" + app
                    + ", appName=" + app.getPackageName()
                    + ", pkg=" + r.packageInfo.getPackageName()
                    + ", comp=" + r.intent.getComponent().toShortString()
                    + ", dir=" + r.packageInfo.getAppDir());

            if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
                if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                        + r.activityInfo.name + " with config " + config);
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor);

                if (customIntent != null) {
                    activity.mIntent = customIntent;
                }
                r.lastNonConfigurationInstances = null;
                activity.mStartedActivity = false;
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }

                activity.mCalled = false;
              //调用activity的oncreate方法
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onCreate()");
                }
                r.activity = activity;
                r.stopped = true;
                if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
                if (!r.activity.mFinished) {
                    if (r.isPersistable()) {
                        if (r.state != null || r.persistentState != null) {
                            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                    r.persistentState);
                        }
                    } else if (r.state != null) {
                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                    }
                }

看 Instrumentation中的callActivityOnCreate()

public void callActivityOnCreate(Activity activity, Bundle icicle) {
        prePerformCreate(activity);
        activity.performCreate(icicle);
        postPerformCreate(activity);
    }

看 activity.performCreate(icicle);

final void performCreate(Bundle icicle) {
        onCreate(icicle);
        mActivityTransitionState.readState(icicle);
        performCreateCommon();
    }

 public void onCreate(@Nullable Bundle savedInstanceState,
            @Nullable PersistableBundle persistentState) {
        onCreate(savedInstanceState);
    }

最后到我写的Activity中的oncreate方法中了

引用被人的图: