Android：MainActivity的调用机制详解

MainActivity 是由Android系统的ActivityManagerService(AMS)和ActivityThread协同调用的。

一、MainActivity被谁调用的？

Android 应用的 MainActivity（或者更一般地说，任何Activity）的启动是由Android系统（具体来说是ActivityManagerService）来调用的

二、详细的调用时序图

用户点击图标 → Launcher → ActivityManagerService (AMS) → Zygote → 
应用进程创建 → ActivityThread.main() → Application创建 → 
AMS通知ActivityThread → ActivityThread.performLaunchActivity() → 
MainActivity创建 → MainActivity.onCreate()

1. 用户点击应用图标：Launcher（桌面应用）会发送一个启动应用的Intent，这个Intent包含了目标应用的MainActivity（在AndroidManifest.xml中声明为LAUNCHER的Activity）。
2. Launcher向ActivityManagerService（AMS）发送启动请求：Launcher通过Binder机制告诉AMS要启动哪个Activity。
3. AMS检查目标应用进程：AMS会检查目标应用（即你开发的应用）的进程是否已经存在。如果不存在，AMS会请求Zygote进程fork出一个新的应用进程。
4. 创建应用进程：Zygote进程fork出新的应用进程后，会执行ActivityThread的main()方法，这是每个应用进程的入口。
5. 初始化应用进程：在ActivityThread的main()方法中，会创建主线程（也就是UI线程），并初始化Looper、Handler等，然后开始消息循环。同时，会创建Application对象（如果还没有创建的话）并调用Application的onCreate()方法。
6. AMS通知应用进程启动目标Activity：AMS通过Binder机制通知应用进程的ActivityThread，要求其启动指定的Activity。
7. ActivityThread处理启动请求：ActivityThread接收到AMS的请求后，会通过Handler发送一个启动Activity的消息。主线程的Handler处理该消息，调用handleLaunchActivity()方法，进而调用performLaunchActivity()方法。
8. 创建Activity实例：在performLaunchActivity()方法中，会通过类加载器创建Activity的实例，然后调用Activity的构造函数。
9. 初始化Activity：创建Activity实例后，会调用Activity的attach()方法，为其关联上下文（Context）等。然后，调用Activity的onCreate()方法。
10. Activity生命周期方法调用：在onCreate()方法中，我们通常会调用setContentView()来设置布局。之后，ActivityThread会继续调用onStart()和onResume()方法，使Activity进入运行状态。
11. 界面显示：经过测量、布局、绘制等步骤后，Activity的界面最终显示在屏幕上。

三、具体调用流程分解

3.1 AMS请求启动MainActivity

当用户点击应用图标时：

1. Launcher通过startActivity()请求启动应用
2. 这个请求最终被发送到ActivityManagerService(AMS)

// Launcher中的代码（简化）
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
intent.setComponent(new ComponentName("com.example.myapp", 
                       "com.example.myapp.MainActivity"));
startActivity(intent);

3.2 创建应用进程

如果应用进程不存在：

1. AMS通过Process.start()请求Zygote fork新进程
2. Zygote创建新进程并执行ActivityThread.main()

// ActivityThread.java (系统框架代码)
public static void main(String[] args) {
    // 1. 初始化主线程Looper
    Looper.prepareMainLooper();
    
    // 2. 创建ActivityThread实例
    ActivityThread thread = new ActivityThread();
    
    // 3. 关联应用进程与AMS
    thread.attach(false);
    
    // 4. 开始消息循环
    Looper.loop();
}

3.3 AMS通知启动MainActivity

// ActivityThread.java中的内部调用链
public void handleMessage(Message msg) {
    switch (msg.what) {
        case LAUNCH_ACTIVITY: {
            // 接收到AMS的启动Activity请求
            handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
            break;
        }
    }
}

private void handleLaunchActivity(ActivityClientRecord r, 
                                  Intent customIntent, String reason) {
    // 1. 创建Activity实例
    Activity activity = performLaunchActivity(r, customIntent);
    
    if (activity != null) {
        // 2. 调用Activity生命周期方法
        handleResumeActivity(r.token, false, r.isForward);
    }
}

3.4 核心创建方法：performLaunchActivity()

// ActivityThread.java (系统框架代码)
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // 1. 获取Activity信息
    ActivityInfo aInfo = r.activityInfo;
    
    // 2. 创建Context
    Context appContext = createBaseContextForActivity(r);
    
    // 3. 反射创建Activity实例（关键步骤！）
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = appContext.getClassLoader();
        // 使用类加载器加载MainActivity类并创建实例
        activity = (Activity) cl.loadClass(className).newInstance();
    } catch (Exception e) {
        // 处理异常
    }
    
    // 4. 创建Application（如果不存在）
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    
    // 5. 关联Activity与上下文
    activity.attach(appContext, ...);
    
    // 6. 调用Activity的onCreate()
    mInstrumentation.callActivityOnCreate(activity, r.state);
    
    return activity;
}

四、关键环节详解

4.1 反射创建MainActivity实例

这是MainActivity被”调用”的核心环节：

// 系统使用反射创建你的MainActivity
// className = "com.example.myapp.MainActivity"
Class<?> activityClass = classLoader.loadClass(className);
Activity activity = (Activity) activityClass.newInstance();

为什么使用反射？

• Android系统不知道你的具体Activity类名
• 需要在运行时动态加载
• 支持插件化、动态加载等特性

4.2 Instrumentation.callActivityOnCreate()

// Instrumentation.java (系统框架代码)
public void callActivityOnCreate(Activity activity, Bundle icicle) {
    // 预处理...
    
    // 调用Activity.onCreate() - 这就是你的代码开始执行的地方！
    activity.onCreate(icicle);
    
    // 后处理...
}

4.3 Activity.attach()方法

在调用onCreate()之前，系统会先调用attach()：

// Activity.java (系统框架代码)
final void attach(Context context, ...) {
    // 1. 关联Window
    mWindow = new PhoneWindow(this);
    
    // 2. 设置WindowManager
    mWindow.setWindowManager(...);
    
    // 3. 设置主题等
    mWindow.setCallback(this);
    
    // 4. 初始化Fragment管理器等
    mFragments.attachHost(null);
}

五、完整的MainActivity创建流程

时序图：

1. AMS.send → Zygote fork进程
2. 新进程执行 ActivityThread.main()
3. ActivityThread.attachApplication() → AMS
4. AMS.sendMessage(LAUNCH_ACTIVITY) → ActivityThread
5. ActivityThread.H 处理消息 → handleLaunchActivity()
6. performLaunchActivity():
   a. 创建Context
   b. 反射创建Activity实例
   c. 创建Application
   d. activity.attach()
   e. mInstrumentation.callActivityOnCreate()
   f. activity.onCreate()  ← 你的代码开始执行！
7. handleResumeActivity() → onStart() → onResume()

六、验证实验

你可以在MainActivity中添加日志来验证调用顺序：

public class MainActivity extends AppCompatActivity {
    
    private static final String TAG = "MainActivity";
    
    // 静态初始化块
    static {
        Log.d(TAG, "静态初始化块执行");
    }
    
    // 构造方法
    public MainActivity() {
        Log.d(TAG, "构造方法执行");
    }
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate执行");
        setContentView(R.layout.activity_main);
    }
    
    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "onStart执行");
    }
    
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume执行");
    }
}

输出日志顺序：

D/MainActivity: 静态初始化块执行
D/MainActivity: 构造方法执行
D/MainActivity: onCreate执行
D/MainActivity: onStart执行
D/MainActivity: onResume执行

七、重要概念总结

1. AMS (ActivityManagerService)

   • 系统服务，管理所有Activity
   • 负责Activity的调度和生命周期管理

2. ActivityThread

   • 每个应用进程的主线程
   • 负责与AMS通信并执行Activity生命周期

3. Instrumentation

   • 监控应用与系统的交互
   • 负责调用Activity的生命周期方法

4. 反射机制

   • 系统通过反射创建Activity实例
   • 这使得系统可以动态加载任何Activity

5. 主线程消息循环

   • Activity生命周期调用都是在主线程的消息队列中处理的
   • 通过Handler机制调度

八、常见问题

Q: MainActivity的构造方法会被调用吗？
A: 会的！在反射创建实例时，会调用默认构造方法。

Q: 为什么不能自己new MainActivity()？
A: 因为Activity需要系统的Context、Window等基础设施，这些都在attach()方法中设置。

Q: 可以在Application中直接启动Activity吗？
A: 可以，但必须在主线程中调用，且要确保Activity的上下文已初始化。

Q: 多个Activity如何共享数据？
A: 可以通过Intent传递、SharedPreferences、数据库或ViewModel等方式。

理解MainActivity的创建流程对于掌握Android架构非常重要。这不仅是面试常考点，也是理解Android应用运行机制的基础。