Android应用程序入口源码解析

---

我们在写C、C++或java应用时，都会有一个main函数，但Android的main函数在哪里呢？偶记得从第一个HelloWorld应用开始，就知道，只要在AndroidManifest配置表中对Activity的intent-filter进行配置，action为android.intent.action.MAIN，category为android.intent.category.LAUNCHER，应用程序启动的时候就会首先启动这个Activity，此Activity也就是应用的入口；后来又知道Application这个类，只要有类继承Application,并在AndroidManifest配置表中对application的name进行配置该类，android应用启动后会把该类的attachBaseContext和onCreate方法作为程序开发入口。实际上是不是这样的呢？本篇博文将会从源码角度来分析。

在说Android应用程序开发入口之前，我们有必要了解一下android系统的启动和Android应用程序的启动流程，这样有助于我们对Android系统有一个整体的认识。首先，让我们来简单了解一下Android系统的启动流程。

一、Android系统的启动

Android系统的启动流程是怎样的呢？首先先来看一下流程图：

根据图，我们知Android启动流程的步骤如下：

• 1.启动电源
  当电源按下时引导芯片代码开始从预定义的地方（固化在ROM）开始执行。加载引导程序Bootloader到RAM，然后执行。

• 2.引导程序BootLoader执行
  引导程序BootLoader是在Android操作系统开始运行前的一个小程序，它的主要作用是把系统OS拉起来并运行。

• 3.Linux内核启动
  内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。当内核完成系统设置，它首先在系统文件中寻找init.rc文件，并启动init进程。

• 4.init进程启动
  初始化和启动属性服务，并且启动Zygote进程。

• 5.Zygote进程启动
  创建JavaVM并为JavaVM注册JNI，创建服务端Socket，启动SystemServer进程。

• 6.SystemServer进程启动
  启动Binder线程池和SystemServiceManager，并且启动各种系统服务，例如：ActivityManagerService、PowerManagerService、PackageManagerService，BatteryService、UsageStatsService等其他80多个系统服务。

• 7.Launcher启动
  被SystemServer进程启动的ActivityManagerService会启动Launcher，Launcher启动后会将已安装应用的快捷图标显示到界面上。

关于Android系统的启动源码分析，这里推荐大神刘望舒的几篇文章，讲得比较详细：

Android系统启动流程（一）解析init进程启动过程

Android系统启动流程（二）解析Zygote进程启动过程

Android系统启动流程（三）解析SyetemServer进程启动过程

Android系统启动流程（四）Launcher启动过程与系统启动流程

二、Android应用程序启动

上面说到，当Android系统启动完成之后，Lancher也就启动完成了，在我们的桌面上就会看到已安装的应用快捷图标。点击快捷图标，就能启动我们的应用程序。我们知道，android系统中的每一个应用程序，都是独立运行在自己的进程中的，所以在点击应用快捷图标后，如果应用程序还没有进程，首先应该会先建立应用程序的进程。具体流程是怎样的呢？我们先来看流程图：

从流程图知，应用程序在没有创建进程的情况下，会通过ActivitServiceManager去请求服务端Socket，服务端Socket再去请求Zygote进程，让其帮忙建立进程，而Zygote进程会fork自身来创建应用程序进程。应用程序进程创建的同时，应用程序的主线程也会创建，与主线程息息相关的ActivityThread类也会创建，并调用自身的main方法，进行相关的初始化。

具体进程是怎么创建的，这里也还是推荐大神刘望舒的两篇文章，其中非常详细的分析了应用进程的创建过程，想了解的可以看一下。

Android应用程序进程启动过程（前篇）

Android应用程序进程启动过程（后篇）

好了，下面我们来继续说说ActivityThread的main方法，也即Android应用程序的入口。

三、Android应用程序入口源码分析

通过Android应用程序的启动，我们知道android应用程序的入口，即ActivityThread的main方法。但在我们开发的时候，很少接触ActivityThread类,主要还是Application和Activity，他俩与ActivityThread的关系怎样呢？让我们从源码中来看看，ActivityThread的main方法：

public static void main(String[] args) {
    SamplingProfilerIntegration.start();

    // CloseGuard defaults to true and can be quite spammy.  We
    // disable it here, but selectively enable it later (via
    // StrictMode) on debug builds, but using DropBox, not logs.
    CloseGuard.setEnabled(false);

    Process.setArgV0("<pre-initialized>");

    Looper.prepareMainLooper();//1.Looper的创建
    if (sMainThreadHandler == null) {
        sMainThreadHandler = new Handler();
    }

    ActivityThread thread = new ActivityThread();//2.ActivityThread初始化
    thread.attach(false);//3.调用ActivityThread附属方法attach

    AsyncTask.init();

    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }

    Looper.loop();//4.Looper消息开始循环

    throw new RuntimeException("Main thread loop unexpectedly exited");
}

在main方法中，主线程的Looper实现了初始化和消息循环，这与Android的消息机制息息相关。关于消息机制，我已写过一个篇文章为Android消息机制源码解析(Handler)，想了解的可以看一下。这里我们主要来看一下ActivityThread的初始化和attach方法，其中ActivityThread初始化构造方法什么也没做，没啥好看的，我们主要来看看attach方法

private void attach(boolean system) {
    sThreadLocal.set(this);
    mSystemThread = system;
    if (!system) {//false，不是system,普通app
        .......省略
        android.ddm.DdmHandleAppName.setAppName("<pre-initialized>");
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        IActivityManager mgr = ActivityManagerNative.getDefault();//1.核心代码
        try {
            mgr.attachApplication(mAppThread);//2.核心代码
        } catch (RemoteException ex) {
            // Ignore
        }
    } else {//true，是system
        // Don't set application object here -- if the system crashes,
        // we can't display an alert, we just want to die die die.
        android.ddm.DdmHandleAppName.setAppName("system_process");
        try {
            mInstrumentation = new Instrumentation();
            ContextImpl context = new ContextImpl();
            context.init(getSystemContext().mPackageInfo, null, this);
            Application app = Instrumentation.newApplication(Application.class, context);
            mAllApplications.add(app);
            mInitialApplication = app;
            app.onCreate();
        } catch (Exception e) {
            throw new RuntimeException(
                    "Unable to instantiate Application():" + e.toString(), e);
        }
    }
   ......省略
}

ActivityThread调用attach()传入的参数是false，不是system。注释1通过静态方法ActivityManagerNative.getDefault()获取IActivityManager,实际上是获取到ActivityManagerProxy类，让我们来看ActivityManagerNative.getDefault()方法,进入ActivityManagerNative类

/**
 * Cast a Binder object into an activity manager interface, generating
 * a proxy if needed.
 */
static public IActivityManager asInterface(IBinder obj) {
    if (obj == null) {
        return null;
    }
    IActivityManager in =
        (IActivityManager)obj.queryLocalInterface(descriptor);
    if (in != null) {
        return in;
    }

    return new ActivityManagerProxy(obj);//核心方法
}

/**
 * Retrieve the system's default/global activity manager.
 */
static public IActivityManager getDefault() {
    return gDefault.get();
}

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

通过查看ActivityManagerProxy类，了解到它实现IActivityManager接口,mgr就是ActivityManagerProxy。知道返回的类后，我们再来看一下注释2，mgr.attachApplication(mAppThread)，其中mAppThread为ApplicationThread，让我们再进入ActivityManagerProxy，看看attachApplication方法

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

    public IBinder asBinder()
    {
        return mRemote;
    }
    .......
    public void attachApplication(IApplicationThread app) throws RemoteException
    {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(app.asBinder());
        mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);//核心代码
        reply.readException();
        data.recycle();
        reply.recycle();
    }
    .......
}

从源码中，了解到mRemote是一个IBinder，通过Binder实现进程间通信(Android核心进程通信方法)，从而调用到ActivityServiceManager里面对应的方法

public final void attachApplication(IApplicationThread thread) {
    synchronized (this) {
        int callingPid = Binder.getCallingPid();
        final long origId = Binder.clearCallingIdentity();
        attachApplicationLocked(thread, callingPid);//核心方法
        Binder.restoreCallingIdentity(origId);
    }
}

我们来继续看方法attachApplicationLocked()

private final boolean attachApplicationLocked(IApplicationThread thread,
         int pid) {
         .......
         thread.bindApplication(processName, appInfo, providers,
                 app.instrumentationClass, profileFile, profileFd, profileAutoStop,
                 app.instrumentationArguments, app.instrumentationWatcher, testMode,
                 enableOpenGlTrace, isRestrictedBackupMode || !normalMode, app.persistent,
                 new Configuration(mConfiguration), app.compat, getCommonServicesLocked(),
                 mCoreSettingsObserver.getCoreSettingsLocked());
         updateLruProcessLocked(app, false, true);
         app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();
       .....

     return true;
 }

在attachApplicationLocked()方法中,细节比较多，我们省略掉了，主要来看一下核心方法bindApplication(),其中thread就是ActivityThread中ApplicationThread类，让我们再来看ApplicationThread中的bindApplication()方法

public final void bindApplication(String processName,
        ApplicationInfo appInfo, List<ProviderInfo> providers,
        ComponentName instrumentationName, String profileFile,
        ParcelFileDescriptor profileFd, boolean autoStopProfiler,
        Bundle instrumentationArgs, IInstrumentationWatcher instrumentationWatcher,
        int debugMode, boolean enableOpenGlTrace, boolean isRestrictedBackupMode,
        boolean persistent, Configuration config, CompatibilityInfo compatInfo,
        Map<String, IBinder> services, Bundle coreSettings) {

    if (services != null) {
        // Setup the service cache in the ServiceManager
        ServiceManager.initServiceCache(services);
    }

    setCoreSettings(coreSettings);

    AppBindData data = new AppBindData();
    data.processName = processName;
    data.appInfo = appInfo;
    data.providers = providers;
    data.instrumentationName = instrumentationName;
    data.instrumentationArgs = instrumentationArgs;
    data.instrumentationWatcher = instrumentationWatcher;
    data.debugMode = debugMode;
    data.enableOpenGlTrace = enableOpenGlTrace;
    data.restrictedBackupMode = isRestrictedBackupMode;
    data.persistent = persistent;
    data.config = config;
    data.compatInfo = compatInfo;
    data.initProfileFile = profileFile;
    data.initProfileFd = profileFd;
    data.initAutoStopProfiler = false;
    queueOrSendMessage(H.BIND_APPLICATION, data);//核心方法
}

其中queueOrSendMessage方法主要就是向Handler发送了一个Message，让我们来看看具体的方法

// if the thread hasn't started yet, we don't have the handler, so just
   // save the messages until we're ready.
   private void queueOrSendMessage(int what, Object obj) {
       queueOrSendMessage(what, obj, 0, 0);
   }

   private void queueOrSendMessage(int what, Object obj, int arg1) {
       queueOrSendMessage(what, obj, arg1, 0);
   }

   private void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
       synchronized (this) {
           if (DEBUG_MESSAGES) Slog.v(
               TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
               + ": " + arg1 + " / " + obj);
           Message msg = Message.obtain();
           msg.what = what;
           msg.obj = obj;
           msg.arg1 = arg1;
           msg.arg2 = arg2;
           mH.sendMessage(msg);
       }
   }

容易知道，主要就是向Handler mH中发送一条消息，根据Handler消息循环机制，可以在handMessage查看处理方法，根据H.BIND_APPLICATION

    private class H extends Handler {
           .....
        public static final int BIND_APPLICATION        = 110;
        public void handleMessage(Message msg) {
            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
            switch (msg.what) {
                .......
                case BIND_APPLICATION:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
                    AppBindData data = (AppBindData)msg.obj;
                    handleBindApplication(data);//核心方法
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                 .......
       }
}

继续看handleBindApplication()方法

private void handleBindApplication(AppBindData data) {
         try {

            .........

            Application app = data.info.makeApplication(data.restrictedBackupMode, null);
            mInitialApplication = app;

           ...... 

            try {
                mInstrumentation.onCreate(data.instrumentationArgs);
            }
            catch (Exception e) {
            }
            try {
                mInstrumentation.callApplicationOnCreate(app);
            } catch (Exception e) {            }
        } finally {
            StrictMode.setThreadPolicy(savedPolicy);
        }
 }

通过分析知data为AppBindData，data.info是一个LoadeApk对象。data.info.makeApplication()，让我们继续看LoadeApk中的方法

public Application makeApplication(boolean forceDefaultAppClass,
           Instrumentation instrumentation) {
       if (mApplication != null) {
           return mApplication;
       }

       Application app = null;

       String appClass = mApplicationInfo.className;
       if (forceDefaultAppClass || (appClass == null)) {
           appClass = "android.app.Application";
       }

       try {
           java.lang.ClassLoader cl = getClassLoader();
           ContextImpl appContext = new ContextImpl();
           appContext.init(this, null, mActivityThread);
           app = mActivityThread.mInstrumentation.newApplication(
                   cl, appClass, appContext);//1.核心方法
           appContext.setOuterContext(app);
       } catch (Exception e) {
           if (!mActivityThread.mInstrumentation.onException(app, e)) {
               throw new RuntimeException(
                   "Unable to instantiate application " + appClass
                   + ": " + e.toString(), e);
           }
       }
       mActivityThread.mAllApplications.add(app);
       mApplication = app;

       if (instrumentation != null) {
           try {
               instrumentation.callApplicationOnCreate(app);//2.核心方法
           } catch (Exception e) {
               if (!instrumentation.onException(app, e)) {
                   throw new RuntimeException(
                       "Unable to create application " + app.getClass().getName()
                       + ": " + e.toString(), e);
               }
           }
       }
       
       return app;
   }

主要还是调ActivityThread中mInstrumentation.newApplication()方法，并传入了继承Application的类的类名appClass，当Applicaiton建立后，马上就调用了方法2即Application的onCreate(),让我们先来看Instrumentation中的newApplication()方法

  
public Application newApplication(ClassLoader cl, String className, Context context)
        throws InstantiationException, IllegalAccessException, 
        ClassNotFoundException {
    return newApplication(cl.loadClass(className), context);
}

static public Application newApplication(Class<?> clazz, Context context)
        throws InstantiationException, IllegalAccessException, 
        ClassNotFoundException {
    Application app = (Application)clazz.newInstance();
    app.attach(context);//方法
    return app;
}

到这里，就建立了应用程序的Application，然而在Application中那个方法是最先调用的呢？让我们继续看一下

/**
 * @hide
 */
/* package */ final void attach(Context context) {
    attachBaseContext(context);
    mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
}

由此我们知道Application初始化后，首先调用的是attachBaseContext()方法，其次才是Application的onCreate方法，让我们看一下调用onCreate()方法,在前面的makeApplication()方法中，有此代码instrumentation.callApplicationOnCreate(app)，我们继续来看看源码

public void callApplicationOnCreate(Application app) {
    app.onCreate();
}

到这里Android应用程序的入口源码就分析完了。

注：源码采用android-4.1.1_r1版本，建议下载源码然后自己走一遍流程，这样更能加深理解。

四、总结

Android应用程序的入口是ActivityThread的main方法，而Android应用程序的开发入口是Application的attachBaseContext()和onCreate()。如果有类继承Application，并在Androidmanifest中配置了，它就会优先启动。在继承Application类初始化后，首先调用的是attachBaseContext()方法，其次才是onCreate方法。

五、相关及参考文档

Activity启动过程全解析

深入理解ActivityManagerService

Android系统启动流程（一）解析init进程启动过程

Android系统启动流程（二）解析Zygote进程启动过程

Android系统启动流程（三）解析SyetemServer进程启动过程

Android系统启动流程（四）Launcher启动过程与系统启动流程

Android应用程序进程启动过程（前篇）

Android应用程序进程启动过程（后篇）

赏

感谢认可，么么哒

支付宝

微信