Android 应用启动那些事儿,Application? Context?

2,059

本文主要总结梳理一下,应用进程启动, 以及应用中各种Context那些事儿,如有错误,欢迎指出~

一,应用进程创建

1,zygote创建新进程

Android 应用程序不能主动开启一个进程,只能被动开启进程。在Mainfest注册四大组件时,可以指定运行的进程。在启动该组件时,AMS首先会判断该进程 是否已存在,如果不存在,则首先请求zygote进程创建该进程。

        <service android:name=".ServiceName"
            android:process=":processName"/>

以启动一个服务为例,程序会先调用ActivityManagerService 中的startService()方法,在该方法内部会调用到ActiveService的bringUpServiceLocked方法 启动服务。

private String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
            boolean whileRestarting, boolean permissionsReviewRequired)
            throws TransactionTooLargeException {
          ......
            app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);
            if (app != null && app.thread != null) {
               app.addPackage(r.appInfo.packageName, r.appInfo.longVersionCode, mAm.mProcessStats);
               realStartServiceLocked(r, app, execInFg);
               return null;
            }

          if (app == null && !permissionsReviewRequired) {
            if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
                    hostingType, r.name, false, isolated, false)) == null) {
                bringDownServiceLocked(r);
                return msg;
            }
         }

        if (!mPendingServices.contains(r)) {
            mPendingServices.add(r);
        }
        return null;
    }

mAm.getProcessRecordLocked()方法 用于判断当前进程是否已经存在,若不存在,则调用ActivityManagerService的startProcessLocked方法创建一个进程。最终会调用到Process的start方法。会请求zygote进程创建一个进程。

    public static final ProcessStartResult start(...) {
        return zygoteProcess.start(processClass, niceName, uid, gid, gids,
                    runtimeFlags, mountExternal, targetSdkVersion, seInfo,
                    abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
    }

ZygoteProcess封装了与zygote进程相关的socket通信。zygote进程创建一个新进程后,会将该新进程的pid 返回当前系统进程中。

    @GuardedBy("mLock")
    private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
            ZygoteState zygoteState, ArrayList<String> args)
            throws ZygoteStartFailedEx {
        try {
            ......
            result.pid = inputStream.readInt();
            result.usingWrapper = inputStream.readBoolean();

            if (result.pid < 0) {
                throw new ZygoteStartFailedEx("fork() failed");
            }
            return result;
        } catch (IOException ex) {
            zygoteState.close();
            throw new ZygoteStartFailedEx(ex);
        }
    }

2,新进程向AMS发布IBinder实体对象

新进程启动后,首先会执行ActivityThread.main函数,在 thread.attach()方法中会通过Binder机制调用AMS的attachApplication方法,实际上就是通知AMS 新进程已创建好,并将自己的IBinder发布到AMS中。

public static void main(String[] args) {
        .....
        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);

        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
private void attach(boolean system, long startSeq) {
        sCurrentActivityThread = this;
        mSystemThread = system;
        if (!system) {
             .....
            RuntimeInit.setApplicationObject(mAppThread.asBinder());
            final IActivityManager mgr = ActivityManager.getService();
            try {
                mgr.attachApplication(mAppThread, startSeq);
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
              .....
    }

3,创建新进程Application对象

当应用进程启动,并向AMS发布自己的IBinder实体对象后,AMS 调用attachApplication()方法创建应用的Application对象。其中,thread为应用进程在AMS进程的binder对象。

   @Override
    public final void attachApplication(IApplicationThread thread, long startSeq) {
        synchronized (this) {
            attachApplicationLocked(thread, callingPid, callingUid, startSeq);
        }
    }
@GuardedBy("this")
 private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
       .....
       thread.bindApplication(...)
       ......
       return true;
    }

bindApplication()方法在应用进程的Binder线程中执行。 首先会封装app数据到AppBindData,然后发送Handler消息,在主线程中执行handleBindApplication()方法。

        public final void bindApplication(...) {
            AppBindData data = new AppBindData();
            .....
            sendMessage(H.BIND_APPLICATION, data);
        }
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case BIND_APPLICATION:
                    AppBindData data = (AppBindData)msg.obj;
                    handleBindApplication(data);
                    break;
    private void handleBindApplication(AppBindData data) {

         //初始化应用程序 基本数据
         ......
        Application app;   
        //创建Appcalition对象
        app = data.info.makeApplication(data.restrictedBackupMode, null);
         ......
         //调用Application.onCreate()方法
         mInstrumentation.callApplicationOnCreate(app);
        ......
    }

通过调用Instrumentation 中的newApplication()方法,通过反射创建Application对象,并调用 Application.attach(Context)生命周期回调方法

    public Application newApplication(ClassLoader cl, String className, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
        Application app = getFactory(context.getPackageName())
                .instantiateApplication(cl, className);
        app.attach(context);
        return app;
    }

至此完成Application的创建工作,由此也可得出,Application并不是与应用相对应,而是与应用进程一一对应。

4,创建service实例

AMS最终会同过Binder机制通知 刚刚创建的进程创建服务类实例,并调用服务相关的生命周期函数。

 private void handleCreateService(CreateServiceData data) {
        LoadedApk packageInfo = getPackageInfoNoCheck(
                data.info.applicationInfo, data.compatInfo);
        Service service = null;

       java.lang.ClassLoader cl = packageInfo.getClassLoader();
       service = packageInfo.getAppFactory()
                    .instantiateService(cl, data.info.name, data.intent);
 
       ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
       context.setOuterContext(service);

       Application app = packageInfo.makeApplication(false, mInstrumentation);
       service.attach(context, this, data.info.name, data.token, app,
                    ActivityManager.getService());
       service.onCreate();          
    }

二,各种Context

1,简介

Context是提供应用程序上下文的一个抽象类,可以用来访问系统资源,系统服务等等。

public abstract class Context {
    public abstract Resources getResources();
    public abstract Context getApplicationContext();
    public abstract String getSystemServiceName(Class<?> serviceClass);
    public abstract void startActivity( Intent intent);
    public abstract ComponentName startService(Intent service);
}

ContextWrapper 是Context的实现类,同时接收一个ContextImp 对象 做静态代理。

public class ContextWrapper extends Context {
    Context mBase;
    public ContextWrapper(Context base) {
        mBase = base;
    }
   
    protected void attachBaseContext(Context base) {
        if (mBase != null) {
            throw new IllegalStateException("Base context already set");
        }
        mBase = base;
    }

    public Context getBaseContext() {
        return mBase;
    }
...
}

ContextImpl 实现Context, 完成具体操作

class ContextImpl extends Context {
 ....
}

2, Application 中的Context

Applicaiton继承ContextWrapper, 具有保存应用进程内的全局变量、初始化操作、提供应用上下文的作用。

public class Application extends ContextWrapper implements ComponentCallbacks2 {
      ...
    public Application() {
        super(null);
    }
     final void attach(Context context) {
        attachBaseContext(context);
    }
    public void onCreate() {
    }
}

应用程序创建Application, 并创建ContextImp对象通过attch赋值给mBase

public Application makeApplication(...){
    ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
    app = mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext);
}
    public Application newApplication(ClassLoader cl, String className, Context context) {
        Application app = getFactory(context.getPackageName())
                .instantiateApplication(cl, className);
        app.attach(context);
        return app;
    }

3, Activity 中的Context

Activity继承ContextThemeWrapper类,而 ContextThemeWrapper继承ContextWrapper,只是封装了主题相关内容。

public class Activity extends ContextThemeWrapper{
    ......
    public final Application getApplication() {
        return mApplication;
    }
    final void attach(...) {
        attachBaseContext(context);
        mApplication = application;
   }
}

应用程序创建Activity

private Activity performLaunchActivity(...){
      ContextImpl appContext = createBaseContextForActivity(r);
      Activity activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);

      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, window, r.configCallback);
}

4, Service 中的Context

Service继承ContextWrapper .

public abstract class Service extends ContextWrapper {
   public final void attach(...) {
        attachBaseContext(context);
        mApplication = application;
    }
    public final Application getApplication() {
        return mApplication;
    }
}

创建Service

  private void handleCreateService(CreateServiceData data) {
      service = packageInfo.getAppFactory() .instantiateService(cl, data.info.name, data.intent);
      ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
      service.attach(context, this, data.info.name, data.token, app,
                    ActivityManager.getService());
      service.onCreate();
  }

5,各种获取Context方法比较

在Activity 或Service中,都可以使用以下三种方法取得Context, 但无论是Application、Activity或Service中,实际发挥作用的都是baseContext中的 ContextImp对象。

        //获取对象是 当前Activity 或Service 本身,慎用,可能会引起内存泄漏
        Context context = this;

        //获取对象是 当前Activity 或Service中的mBase, 即ContextImpl实例
        Context baseContext = getBaseContext();

        //以下两种方法获取的都是当前应用的Application对象, 可以放心使用
        Application application = getApplication();
        Context applicationContext = getApplicationContext();

完~