VirtualApp 中的进程

一. 什么是进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。 – 来自百度百科

二. VA进程

VA在运行时，存在四种类型的进程:
* Server Process: 进程名hostPackageName:x，参照Android system_server进程实现，用于管理VPackageManagerService，VActivityManagerService等服务。
* VAppClient Process: 进程名hostPackageName:p[0~…]，VA容器中安装的第三方应用将运行在此类进程中。
* Main Process: 宿主应用主进程。
* Child Process: 宿主应用子进程。

com/lody/virtual/client/core/VirtualCore.java

/**
 * Process type
 */
private enum ProcessType {
    /**
     * Server process
     */
    Server,
    /**
     * Virtual app process
     */
    VAppClient,
    /**
     * Main process
     */
    Main,
    /**
     * Child process
     */
    CHILD
}

2.1 Server进程

Android通过system_server进程来管理整个Java framework层，包含ActivityManager，PackageManager等各种系统服务；在系统启动的时候就会启动该进程。

VA是一个开源的Android应用容器框架，允许用户在应用中创建虚拟空间，并且安装第三方应用到该虚拟空间中。为了保证应用可以无感知的运行在容器中，VA参照framework源码实现，构造了一个能够运行app的环境。
VA利用ContentProvider的同步特性构建了一套跨进程同步通信机制，把ContentProvider当作一个ServiceManager，所有的系统服务都放在这里管理，利用ContentProvider call的同步调用方式，把Binder对象透传到不同的进程；

com/lody/virtual/server/BinderProvider.java

在BinderProvider的onCreate中会初始化VPackageManagerService, VActivityManagerService, VAppManagerService等服务，这些服务均能在Android framework中找到缩影(PackageManagerService, ActivityManangerService等)。并把实例化的Service存储到ServiceCache的sCache Map中。

@Override
public boolean onCreate() {
    ...
    VPackageManagerService.systemReady();
    addService(ServiceManagerNative.PACKAGE, VPackageManagerService.get());
    VActivityManagerService.systemReady(context);
    addService(ServiceManagerNative.ACTIVITY, VActivityManagerService.get());
    addService(ServiceManagerNative.USER, VUserManagerService.get());
    VAppManagerService.systemReady();
    addService(ServiceManagerNative.APP, VAppManagerService.get());
    BroadcastSystem.attach(VActivityManagerService.get(), VAppManagerService.get());
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        addService(ServiceManagerNative.JOB, VJobSchedulerService.get());
    }
    VNotificationManagerService.systemReady(context);
    addService(ServiceManagerNative.NOTIFICATION, VNotificationManagerService.get());
    VAppManagerService.get().scanApps();
    VAccountManagerService.systemReady();
    addService(ServiceManagerNative.ACCOUNT, VAccountManagerService.get());
    addService(ServiceManagerNative.VS, VirtualStorageService.get());
    return true;
}


private void addService(String name, IBinder service) {
    ServiceCache.addService(name, service);
}

com/lody/virtual/server/ServiceCache.java

public class ServiceCache {

    private static final Map<String, IBinder> sCache = new ArrayMap<>(5);

    public static void addService(String name, IBinder service) {
        sCache.put(name, service);
    }

    public static IBinder removeService(String name) {
        return sCache.remove(name);
    }

    public static IBinder getService(String name) {
        return sCache.get(name);
    }

}

了解源码的同学都知道，ActivityManagerService、PackageManagerService等系统服务，在每个进程中都对应一个Client(ActivityManager, PackageManager)。VA参照源码的实现，在Server进程中启动VPackageManagerService，VActivityManagerService等系统服务，在每个进程中也有对应的Client(VActivityManager，VPackageManager)。

2.2 Client与Server通信

以VActivityManager与VActivityManagerService通信为例，其他Service流程类似。

com/lody/virtual/client/ipc/VActivityManager.java

业务层调用VActivityManager的任意方法，会先调用getService()方法获取IActivityManager。

public IActivityManager getService() {
    if (mRemote == null || !mRemote.asBinder().isBinderAlive()) {
        synchronized (VActivityManager.class) {
            final Object remote = getRemoteInterface();
            mRemote = LocalProxyUtils.genProxy(IActivityManager.class, remote);
        }
    }
    return mRemote;
}

private Object getRemoteInterface() {
    return IActivityManager.Stub
            .asInterface(ServiceManagerNative.getService(ServiceManagerNative.ACTIVITY));
}

com/lody/virtual/client/ipc/ServiceManagerNative.java

ServiceManagerNative的getService方法中，先判断是否为Server进程:
* 是，直接从ServiceCache的Map中获取对应的Service。
* 不是，会通过authorities获取BinderProvider，并调用BinderProvider的call方法，参数method为”@”。

public static String SERVICE_CP_AUTH = "virtual.service.BinderProvider";

public static IBinder getService(String name) {
    if (VirtualCore.get().isServerProcess()) {
        return ServiceCache.getService(name);
    }
    IServiceFetcher fetcher = getServiceFetcher();
    if (fetcher != null) {
        try {
            return fetcher.getService(name);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
    VLog.e(TAG, "GetService(%s) return null.", name);
    return null;
}

private static IServiceFetcher getServiceFetcher() {
    if (sFetcher == null || !sFetcher.asBinder().isBinderAlive()) {
        synchronized (ServiceManagerNative.class) {
            Context context = VirtualCore.get().getContext();
            Bundle response = new ProviderCall.Builder(context, SERVICE_CP_AUTH).methodName("@").call();
            if (response != null) {
                IBinder binder = BundleCompat.getBinder(response, "_VA_|_binder_");
                linkBinderDied(binder);
                sFetcher = IServiceFetcher.Stub.asInterface(binder);
            }
        }
    }
    return sFetcher;
}

<provider
    android:name="com.lody.virtual.server.BinderProvider"
    android:authorities="${applicationId}.virtual.service.BinderProvider"
    android:exported="false"
    android:process=":x" />

com/lody/virtual/client/ipc/ProviderCall.java

通过传入的authority，查找对应的ContentProvider，并调用ContentProvider的call方法。

public class ProviderCall {

    public static Bundle call(String authority, String methodName, String arg, Bundle bundle) {
        return call(authority, VirtualCore.get().getContext(), methodName, arg, bundle);
    }

    public static Bundle call(String authority, Context context, String method, String arg, Bundle bundle) {
        Uri uri = Uri.parse("content://" + authority);
        return ContentProviderCompat.call(context, uri, method, arg, bundle);
    }

    public static final class Builder {

        private Context context;

        private Bundle bundle = new Bundle();

        private String method;
        private String auth;
        private String arg;

        public Builder(Context context, String auth) {
            this.context = context;
            this.auth = auth;
        }

        public Builder methodName(String name) {
            this.method = name;
            return this;
        }

        public Builder arg(String arg) {
            this.arg = arg;
            return this;
        }

        public Builder addArg(String key, Object value) {
            if (value != null) {
                 if (value instanceof Boolean) {
                    bundle.putBoolean(key, (Boolean) value);
                } else if (value instanceof Integer) {
                    bundle.putInt(key, (Integer) value);
                } else if (value instanceof String) {
                    bundle.putString(key, (String) value);
                } else if (value instanceof Serializable) {
                    bundle.putSerializable(key, (Serializable) value);
                } else if (value instanceof Bundle) {
                    bundle.putBundle(key, (Bundle) value);
                } else if (value instanceof Parcelable) {
                    bundle.putParcelable(key, (Parcelable) value);
                } else {
                    throw new IllegalArgumentException("Unknown type " + value.getClass() + " in Bundle.");
                }
            }
            return this;
        }

        public Bundle call() {
            return ProviderCall.call(auth, context, method, arg, bundle);
        }

    }

}

com/lody/virtual/helper/compat/ContentProviderCompat.java

public static Bundle call(Context context, Uri uri, String method, String arg, Bundle extras) {
    if (VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) {
        return context.getContentResolver().call(uri, method, arg, extras);
    }
    ContentProviderClient client = crazyAcquireContentProvider(context, uri);
    Bundle res = null;
    try {
        res = client.call(method, arg, extras);
    } catch (RemoteException e) {
        e.printStackTrace();
    } finally {
        releaseQuietly(client);
    }
    return res;
}

com/lody/virtual/server/BinderProvider.java

BinderProvider的call方法会将mServiceFetcher封装到Bundle中返回给Client。Client端可以通过ServiceFetcher的getService()方法获取Server端启动时存储在ServiceCache中的Service。至此，Client与Server可以通过getService进行方法调用，建立通信了。

@Override
private final ServiceFetcher mServiceFetcher = new ServiceFetcher();

public Bundle call(String method, String arg, Bundle extras) {
    if ("@".equals(method)) {
        Bundle bundle = new Bundle();
        BundleCompat.putBinder(bundle, "_VA_|_binder_", mServiceFetcher);
        return bundle;
    }
    return null;
}

private class ServiceFetcher extends IServiceFetcher.Stub {
    @Override
    public IBinder getService(String name) throws RemoteException {
        if (name != null) {
            return ServiceCache.getService(name);
        }
        return null;
    }

    @Override
    public void addService(String name, IBinder service) throws RemoteException {
        if (name != null && service != null) {
            ServiceCache.addService(name, service);
        }
    }

    @Override
    public void removeService(String name) throws RemoteException {
        if (name != null) {
            ServiceCache.removeService(name);
        }
    }
}

三. 总结

至此，我们已经打通了VA构建在ContentProvider机制上的同步通信方式。利用ContentProvider来模拟framework层的ServiceManager，使整个框架的核心得以摆脱AIDL Service异步过程的苦恼，代码看起来比较整洁，用起来也非常方便；同时，这个机制也解决了插件之间跨进程通信的难题；类似DroidPlugin这样的多进程机制的插件系统，如果插件之间需要通信，必须使用IPC机制：广播，AIDL等等，这些通信都是异步的，写起来非常麻烦；而构建在ContentProvider机制上的同步AIDL通信使得插件的跨进程通信就像普通函数调用一样简单。

四. 参考

• 如何看待 Lody 新开源的 VirtualApp 插件框架？