1. 外掛化原理

DL框架的原理很簡單：

在宿主apk中，有一個ProxyActivity，即代理Activity，這個Activity相當於一個空殼，外掛中的Activity依靠ProxyActivity來對生命週期回撥、資源載入以及啟動另一個Activity等等。總而言之，ProxyActivity提供Context，外掛Activity依靠ProxyActivity來做自己想做的事情。

2. DL的實現

首先看看ProxyActivity的實現：

public class ProxyActivity extends Activity {   

    private
 
 static final String TAG = "ProxyActivity";   

    public static final String FROM = "extra.from";   
    public static final int FROM_EXTERNAL = 0;   
    public static final int FROM_INTERNAL = 1;   

    public static final String EXTRA_DEX_PATH = "extra.dex.path";   
    public static final String EXTRA_CLASS = "extra.class"
 
;   

    private String mClass;   
    private String mDexPath;   

    @Override   
    protected void onCreate(Bundle savedInstanceState) {   
        super.onCreate(savedInstanceState);   
        mDexPath = getIntent().getStringExtra(EXTRA_DEX_PATH);   
        mClass = getIntent().getStringExtra(EXTRA_CLASS);   

        Log.d(TAG, "mClass="
 
 + mClass + " mDexPath=" + mDexPath);   
        if (mClass == null) {   
            launchTargetActivity();   
        } else {   
            launchTargetActivity(mClass);   
        }   
    }   

    @SuppressLint("NewApi")   
    protected void launchTargetActivity() {   
        PackageInfo packageInfo = getPackageManager().getPackageArchiveInfo(   
                mDexPath, 1);   
        if ((packageInfo.activities != null)   
                && (packageInfo.activities.length > 0)) {   
            String activityName = packageInfo.activities[0].name;   
            mClass = activityName;   
            launchTargetActivity(mClass);   
        }   
    }   

    @SuppressLint("NewApi")   
    protected void launchTargetActivity(final String className) {   
        Log.d(TAG, "start launchTargetActivity, className=" + className);   
        File dexOutputDir = this.getDir("dex", 0);   
        final String dexOutputPath = dexOutputDir.getAbsolutePath();   
        ClassLoader localClassLoader = ClassLoader.getSystemClassLoader();   
        DexClassLoader dexClassLoader = new DexClassLoader(mDexPath,   
                dexOutputPath, null, localClassLoader);   
        try {   
            Class<?> localClass = dexClassLoader.loadClass(className);   
            Constructor<?> localConstructor = localClass   
                    .getConstructor(new Class[] {});   
            Object instance = localConstructor.newInstance(new Object[] {});   
            Log.d(TAG, "instance = " + instance);   

            Method setProxy = localClass.getMethod("setProxy",   
                    new Class[] { Activity.class });   
            setProxy.setAccessible(true);   
            setProxy.invoke(instance, new Object[] { this });   

            Method onCreate = localClass.getDeclaredMethod("onCreate",   
                    new Class[] { Bundle.class });   
            onCreate.setAccessible(true);   
            Bundle bundle = new Bundle();   
            bundle.putInt(FROM, FROM_EXTERNAL);   
            onCreate.invoke(instance, new Object[] { bundle });   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
    }   

}

可以看到，這裡的ProxyActivity目前只是實現從外掛apk中載入類並例項化，然後再將這個ProxyActivity例項物件通過setProxy函式賦值給外掛apk中的類。再呼叫apk中類的onCreate函式。
也就是說，外掛apk中的Activity需要持有ProxyActivity的引用，即外掛apk的Activity有了Context物件的引用，以後外掛中的Activity啟動第二個Activity或者是呼叫其他需要Context引數的函式時候，就可以通過ProxyActivity來做到了。
因為每個外掛Activity都需要提供setProxy()函式，以及還需要判斷：

當前的外掛apk是使用者自己安裝的還是通過宿主apk加載出來的

所以，外掛apk中所有的Activity需要一系列的相同程式碼，我們只需建立一個BaseActivity，把這些工作放到BaseActivity，這樣就可以避免寫重複程式碼，而且也可以讓我們外掛中的Activity更“像”正常的Activity。

看看BaseActivity:

import android.app.Activity;   
import android.content.Intent;   
import android.os.Bundle;   
import android.util.Log;   
import android.view.View;   
import android.view.ViewGroup.LayoutParams;   

public class BaseActivity extends Activity {   

    private static final String TAG = "Client-BaseActivity";   

    public static final String FROM = "extra.from";   
    public static final int FROM_EXTERNAL = 0;   
    public static final int FROM_INTERNAL = 1;   
    public static final String EXTRA_DEX_PATH = "extra.dex.path";   
    public static final String EXTRA_CLASS = "extra.class";   

    public static final String PROXY_VIEW_ACTION = "com.ryg.dynamicloadhost.VIEW";   
    public static final String DEX_PATH = "/mnt/sdcard/DynamicLoadHost/plugin.apk";   

    protected Activity mProxyActivity;   
    protected int mFrom = FROM_INTERNAL;   

    public void setProxy(Activity proxyActivity) {   
        Log.d(TAG, "setProxy: proxyActivity= " + proxyActivity);   
        mProxyActivity = proxyActivity;   
    }   

    @Override   
    protected void onCreate(Bundle savedInstanceState) {   
        if (savedInstanceState != null) {   
            mFrom = savedInstanceState.getInt(FROM, FROM_INTERNAL);   
        }   
        if (mFrom == FROM_INTERNAL) {   
            super.onCreate(savedInstanceState);   
            mProxyActivity = this;   
        }   
        Log.d(TAG, "onCreate: from= " + mFrom);   
    }   

    protected void startActivityByProxy(String className) {   
        if (mProxyActivity == this) {   
            Intent intent = new Intent();   
            intent.setClassName(this, className);   
            this.startActivity(intent);   
        } else {   
            Intent intent = new Intent(PROXY_VIEW_ACTION);   
            intent.putExtra(EXTRA_DEX_PATH, DEX_PATH);   
            intent.putExtra(EXTRA_CLASS, className);   
            mProxyActivity.startActivity(intent);   
        }   
    }   

    @Override   
    public void setContentView(View view) {   
        if (mProxyActivity == this) {   
            super.setContentView(view);   
        } else {   
            mProxyActivity.setContentView(view);   
        }   
    }   

    @Override   
    public void setContentView(View view, LayoutParams params) {   
        if (mProxyActivity == this) {   
            super.setContentView(view, params);   
        } else {   
            mProxyActivity.setContentView(view, params);   
        }   
    }   

    @Deprecated   
    @Override   
    public void setContentView(int layoutResID) {   
        if (mProxyActivity == this) {   
            super.setContentView(layoutResID);   
        } else {   
            mProxyActivity.setContentView(layoutResID);   
        }   
    }   

    @Override   
    public void addContentView(View view, LayoutParams params) {   
        if (mProxyActivity == this) {   
            super.addContentView(view, params);   
        } else {   
            mProxyActivity.addContentView(view, params);   
        }   
    }   
}

可以看到，在BaseActivity的onCreate函式中，通過判斷當前的Activity啟動時來自宿主Apk還是使用者自己安裝來設定mProxyActivity物件，如果是使用者自己安裝的，直接賦值this，如果是來自宿主apk的呼叫，則賦值為宿主中的ProxyActivity物件。

3. DL的資源管理和生命週期

前面我們的ProxyActivity只是簡單回調了onCreate函式，還有其他的函式根本沒有呼叫。另外，外掛APK中的Activity的佈局檔案是外掛APK中的資原始檔，並不存在於宿主的APK中，無法通過ProxyActivity的Context來載入，因此，如果外掛中的Activity使用類似R.layout.XXX的方式會出錯。接下來要解決兩個問題。

3.1 資源管理

既然外掛中的Activity無法直接通過ProxyActivity這個Context來載入，那麼我們可以通過反射機制，修改ProxyActivity中跟載入資源相關的api，使得能直接通過ProxyActivity載入資源。
Context中，跟資源相關的api就是如下兩個抽象函式：

 /** Return an AssetManager instance for your application's package. */ 
    public abstract AssetManager getAssets(); 

    /** Return a Resources instance for your application's package. */ 
    public abstract Resources getResources();

也就是說，只要我們重寫這兩個函式，使得返回的AssetManager和Resources物件在載入資源時，能夠去我們的外掛apk中尋找資源，這樣就可以解決問題啦。
首先，我們看看如何構造能夠從外掛apk中查詢資源的AssetManager和Resources物件。通過loadResources函式來構造這兩個物件，程式碼如下所示：

protected void loadResources() {   
    try {   

        AssetManager assetManager = AssetManager.class.newInstance();   
        Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);   
         //通過反射機制，呼叫AssetManager物件的addAssetPath函式 
         //傳入的String引數mDexPath就是我們的外掛apk路徑 
         //為assetManager物件新增一條資源查詢目錄 
        addAssetPath.invoke(assetManager, mDexPath);   
        //將我們構造出來的AssetManager物件儲存到成員變數 
        mAssetManager = assetManager;   
    } catch (Exception e) {   
        e.printStackTrace();   
    }   
    Resources superRes = super.getResources();   
    //構造Resources物件 
    mResources = new Resources(mAssetManager, superRes.getDisplayMetrics(),   
            superRes.getConfiguration());   
    mTheme = mResources.newTheme();   
    mTheme.setTo(super.getTheme());   
}

說明：載入的方法是通過反射.

通過呼叫AssetManager中的addAssetPath方法，我們可以將一個apk中的資源載入到Resources中.

由於addAssetPath是隱藏api我們無法直接呼叫，所以只能通過反射，下面是它的宣告，通過註釋我們可以看出，傳遞的路徑可以是zip檔案也可以是一個資源目錄，而apk就是一個zip，所以直接將apk的路徑傳給它，資源就載入到AssetManager中了，然後再通過AssetManager來建立一個新的Resources物件，這個物件就是我們可以使用的apk中的資源了，這樣我們的問題就解決了。

/**  
 * Add an additional set of assets to the asset manager.  This can be  
 * either a directory or ZIP file.  Not for use by applications.  Returns  
 * the cookie of the added asset, or 0 on failure.  
 * {@hide}  
 */   
public final int addAssetPath(String path) {   
    int res = addAssetPathNative(path);   
    return res;   
}

接下來就是，我們重寫那兩個抽象函式：

    @Override   
    public AssetManager getAssets() {   
        return mAssetManager == null ? super.getAssets() : mAssetManager;   
    }   

    @Override   
    public Resources getResources() {   
        return mResources == null ? super.getResources() : mResources;   
    }

好啦，資源載入的問題解決了，我們可以在外掛中的Activity使用R開頭的資源啦！

3.2 生命週期

個人感覺，生命週期比較好管理，因為ProxyActivity本身就是有生命週期的，只需在ProxyActivity中回撥外掛Activty的對應的生命週期函式即可。
首先，把需要回調的生命週期函式通過反射的方法，儲存起來：

//傳入的localClass即為外掛中的Activty 
protected void instantiateLifecircleMethods(Class<?> localClass) {   
    String[] methodNames = new String[] {   
            "onRestart",   
            "onStart",   
            "onResume",   
            "onPause",   
            "onStop",   
            "onDestory"   
    };   
    for (String methodName : methodNames) {   
        Method method = null;   
        try {   
            method = localClass.getDeclaredMethod(methodName, new Class[] { });   
            method.setAccessible(true);   
        } catch (NoSuchMethodException e) {   
            e.printStackTrace();   
        }   
        mActivityLifecircleMethods.put(methodName, method);   
    }   

    Method onCreate = null;   
    try {   
        onCreate = localClass.getDeclaredMethod("onCreate", new Class[] { Bundle.class });   
        onCreate.setAccessible(true);   
    } catch (NoSuchMethodException e) {   
        e.printStackTrace();   
    }   
    mActivityLifecircleMethods.put("onCreate", onCreate);   

    Method onActivityResult = null;   
    try {   
        onActivityResult = localClass.getDeclaredMethod("onActivityResult",   
                new Class[] { int.class, int.class, Intent.class });   
        onActivityResult.setAccessible(true);   
    } catch (NoSuchMethodException e) {   
        e.printStackTrace();   
    }   
    mActivityLifecircleMethods.put("onActivityResult", onActivityResult);   
}

然後，在ProxyActivity的各個生命週期函式中，對外掛Activity的生命週期函式進行回撥：

@Override   
protected void onResume() {   
    super.onResume();   
    Method onResume = mActivityLifecircleMethods.get("onResume");   
    if (onResume != null) {   
        try {   
            onResume.invoke(mRemoteActivity, new Object[] { });   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
    }   
}   

@Override   
protected void onPause() {   
    Method onPause = mActivityLifecircleMethods.get("onPause");   
    if (onPause != null) {   
        try {   
            onPause.invoke(mRemoteActivity, new Object[] { });   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
    }   
    super.onPause();   
}

現在就解決了生命週期的問題啦！

4. 總結

總結一下DL框架的思想：
其本質就是，整個過程中，在Android系統中管理的Activity只是宿主apk中的ProxyActivity，而外掛中的Activity本質就是個普通類而已，只不過ProxyActivity所有的邏輯程式碼（資源載入、佈局顯示等等）通過外掛中的Activity來完成。
因此，在理解的時候，可以參照如下：

站在宿主apk的角度去想的時候：

外掛中的Activity只是ProxyActivity呼叫的“工具類”，這個“工具類”幫助ProxyActivity執行佈局顯示等等相關的邏輯。

站在外掛Activity的角度去想的時候：

當前外掛Activity沒有實際的上下文，我們需要藉助ProxyActivity提供的上下文來完成Android系統環境中的api的呼叫。