Condom是用于防止第三方唤醒行为的框架，比较小众，这里做下最近使用和学习笔记。

基本操作

Condom 提供基础两个操作。
提供给第三方Context包装，监控在本进程中的唤醒行为。

XxxClient.init(CondomContext.wrap(context, "XxxSDK"),...);

提供进程隔离唤醒处理

CondomProcess.installExceptDefaultProcess(this)

另外提供完全自定义隔离入口

CondomProcess.installExcept(final Application app, final CondomOptions options, final String... process_names)

主要结构说明

Condom框架功能结构上比较清晰。以下为记录的主要功能说明

CondomOptions配置项说明

OutboundType

OutboundType提供发生校验时所进行的操作，结合OutboundJudge使用可以精确自定义校验处理。
但是发生自定义校验仅限于所发生的行为是针对非项目内的的操作才会执行该回调，比如所执行startService中Intent的packagename为非本项目。

原理探索

验证器 - CondomCore

CondomCore主要负责验证逻辑，无论在哪种拦截处都需要执行这里的验证逻辑，所以需要先熟悉这里面的逻辑。

主要拦截操作

调整操作

结论

在核心操作中，可以知道Condom主要在两个方面进行拦截。

调用时验证

在Intent执行调用时，对Intent信息进行监控，如果所指向的对象为关联项目（非其他无关应用）则视为合法操作，这样可以防止启动其他无关项目，另外为了保证效果在启动的Intent又加入对应的限制性Flag，防止后台已经被关闭停止的应用被启动。

查询后验证

在对系统、包信息等查询信息动作时，除了在查询动作前进行拦截外（有些操作需要Intent还是会被第一项所约束），还会执行对查询结果的过滤。如果所查询应用的uid为非相关应用则会被过滤，或者在非相关uid查询操作后，根据自定义过滤动作进行过滤。

拦截器 - CondomContext 、CondomProcess

验证逻辑有了，剩下的就是寻找切面时机。从验证逻辑中可以清楚知道验证所针对的功能目标是启动行为和查询行为。

CondomContext 提供两个入口：

包装Context

在大部分情况下第三方应用如果需要在主项目中执行调用、查询行为，大部分都是使用Context引用进行相关操作，所以较多第三方SDK初始化的第一步就是需要主项目传入其Context。
应对这种方式，Condom提供对需要提供给第三方框架Context进行包装的方法。

CondomContext.wrap(Context, String)

通过代理Context（CondomContext）来监控方法调用情况。

CondomContext的包装Context实现均来自CondomContext自身构造中

private CondomContext(final CondomCore condom, final @Nullable Context app_context, final @Nullable @Size(max=16) String tag) {
        super(condom.mBase);
        final Context base = condom.mBase;
        mCondom = condom;
        mApplicationContext = app_context != null ? app_context : this;
        mBaseContext = new Lazy<Context>() { @Override protected Context create() {
            return new PseudoContextImpl(CondomContext.this);
        }};
        mPackageManager = new Lazy<PackageManager>() { @Override protected PackageManager create() {
            return new CondomPackageManager(base.getPackageManager());
        }};
        mContentResolver = new Lazy<ContentResolver>() { @Override protected ContentResolver create() {
            return new CondomContentResolver(base, base.getContentResolver());
        }};
        TAG = CondomCore.buildLogTag("Condom", "Condom.", tag);
    }

在构造中对PackageManager、ContentResolver、BaseContext、Applicaiton 又进行重新包装并在CondomContext中重写Context的相关实现。在代理类中实现对方法执行的调用校验。

    @Override public ContentResolver getContentResolver() { return mContentResolver.get(); }
    @Override public PackageManager getPackageManager() { return mPackageManager.get(); }
    @Override public Context getApplicationContext() { return mApplicationContext; }
    @Override public Context getBaseContext() {
        mCondom.logConcern(TAG, "getBaseContext");
        return mBaseContext.get();
    }

进程隔离

除了包装层面，Condom还提供进程隔离的处理，通过动态代理，将 ActivityManagerNative 中的 gDefault（IActivityManager) 和 ActivityThread中的sPackageManager（IPackageManager）进行代理

以下为相关代码：

动态代理ActivityManager

@SuppressLint("PrivateApi") private static void installCondomProcessActivityManager(final CondomCore condom)
            throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        final Class<?> ActivityManagerNative = Class.forName("android.app.ActivityManagerNative");
        Field ActivityManagerNative_gDefault = null;
        if (SDK_INT <= N_MR1) try {
            ActivityManagerNative_gDefault = ActivityManagerNative.getDeclaredField("gDefault");
        } catch (final NoSuchFieldException ignored) {}     // ActivityManagerNative.gDefault is no longer available on Android O.
        if (ActivityManagerNative_gDefault == null) {
            ActivityManagerNative_gDefault = ActivityManager.class.getDeclaredField("IActivityManagerSingleton");
        }
        ActivityManagerNative_gDefault.setAccessible(true);
        final Class<?> Singleton = Class.forName("android.util.Singleton");
        final Method Singleton_get = Singleton.getDeclaredMethod("get");
        Singleton_get.setAccessible(true);
        final Field Singleton_mInstance = Singleton.getDeclaredField("mInstance");
        Singleton_mInstance.setAccessible(true);
        final Class<?> IActivityManager = Class.forName("android.app.IActivityManager");

        final Object/* Singleton */singleton = ActivityManagerNative_gDefault.get(null);
        if (singleton == null) throw new IllegalStateException("ActivityManagerNative.gDefault is null");
        final Object/* IActivityManager */am = Singleton_get.invoke(singleton);
        if (am == null) throw new IllegalStateException("ActivityManagerNative.gDefault.get() returns null");

        if (Proxy.isProxyClass(am.getClass()) && Proxy.getInvocationHandler(am) instanceof CondomProcessActivityManager) {
            Log.d(TAG, "CondomActivityManager is already installed in this process.");
            return;
        }

        final Object condom_am = Proxy.newProxyInstance(condom.mBase.getClassLoader(), new Class[] {IActivityManager}, new CondomProcessActivityManager(condom, am));
        Singleton_mInstance.set(singleton, condom_am);
    }

动态代理 PackageManager

@SuppressLint("PrivateApi") private static void installCondomProcessPackageManager(final CondomCore condom)
            throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        final Class<?> ActivityThread = Class.forName("android.app.ActivityThread");
        final Field ActivityThread_sPackageManager = ActivityThread.getDeclaredField("sPackageManager");
        ActivityThread_sPackageManager.setAccessible(true);
        final Class<?> IPackageManager = Class.forName("android.content.pm.IPackageManager");

        final Object pm = ActivityThread_sPackageManager.get(null);
        if (Proxy.isProxyClass(pm.getClass()) && Proxy.getInvocationHandler(pm) instanceof CondomProcessPackageManager) {
            Log.d(TAG, "CondomPackageManager is already installed in this process.");
            return;
        }

        final Object condom_pm = Proxy.newProxyInstance(condom.mBase.getClassLoader(), new Class[] {IPackageManager}, new CondomProcessPackageManager(condom, pm));
        ActivityThread_sPackageManager.set(null, condom_pm);
    }

同样的既然是动态代理也需要实现其代理类

    @VisibleForTesting static class CondomProcessActivityManager extends CondomSystemService {

        private Object proceed(final Object proxy, final Method method, final Object[] args) throws Exception {
            ...
            case "broadcastIntent":
                ...
            case "bindService":
                ...
            case "startService":
                ...
            case "getContentProvider":
                ...
            }
            return super.invoke(proxy, method, args);
        }

        ...
    }

@VisibleForTesting static class CondomProcessPackageManager extends CondomSystemService {

        private Object proceed(final Object proxy, final Method method, final Object[] args) throws Exception {
            ...
            case "queryIntentServices":
                ...
            case "resolveService":
                ...
            case "resolveContentProvider":
                ...
            case "getInstalledApplications":
            case "getInstalledPackages":
                ...
            }
            return super.invoke(proxy, method, args);
        }

        ...
    }