• Android 插件化

    demo

    如果要加载插件模块编译的apk插件包中的Activity类，需要执行如下流程：

    1）加载类对象：使用DexClassLoader加载Activity对应的Class字节码类对象；

    2）管理生命周期：处理加载进来的Activity类的生命周期，创建ProxyActivity，通过其生命周期回调，管理插件包中加载的未纳入应用管理的组件Activity类；

    3）注入上下文：为加载进来的Activity类注入上下文；

    4）加载资源：使用AssetManager将插件包apk中的资源主动加载进来。
     

    1.创建工程

    app为宿主app 

    plugin 为插件app

    plugin_core为插件化的核心加载文件

    2.app

    1. //配置selinux权限：allow untrusted_app app_data_file:file { execute };
    2. public class MainActivity extends AppCompatActivity {
    3.  
    4.     @Override
    5.  
    6.     protected void onCreate(Bundle savedInstanceState) {
    7.  
    8.         super.onCreate(savedInstanceState);
    9.  
    10.         setContentView(R.layout.activity_main);
    11.  
    12.  
    13.         if(checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
    14.                 && checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) { //有存储权限
    15. //           路径为 /storage/emulated/0/Android/data/com.example.insert/files
    16.             String path = getExternalFilesDir(null).getPath()+"/plugin-debug.apk"; //插件模块apk存放位置
    17.  
    18.             PluginManager.getInstance().loadPlugin( this, path); // 加载插件模块的apk文件
    19.  
    20.         } else { //没有存储权限，申请权限
    21.  
    22.             requestPermissions(new String[]{ Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE}, 100);
    23.  
    24.         }
    25.  
    26.     }
    27.  
    28.     public void onClick(View view) {
    29.  
    30.         //要跳转到plugin_core模块的代理Activity，首先要获取插件apk中的入口Activity类
    31.  
    32.         Intent intent = new Intent(this, ProxyActivity.class);
    33.  
    34.         ActivityInfo[] activityInfos = PluginManager.getInstance().getmPackageInfo().activities; // 获取插件apk中的Activity数组信息
    35.  
    36.         if (activityInfos.length > 0) { // 获取的插件包中的Activity不为空 , 才进行界面跳转
    37.  
    38.             // 取插件apk中的第1个Activity，次序就是在AndroidManifest.xml清单文件中定义Activity组件的次序，因此必须将Launcher Activity定义在第一个位置，不能在Launcher Activity之前定义Activity组件
    39.  
    40.             intent.putExtra("className", activityInfos[0].name); // 传入的是代理的目标组件的全类名，即插件apk中第一个activity的全类名
    41.  
    42.             startActivity(intent);
    43.  
    44.         }
    45.  
    46.     }
    47.  
    48. }
    1. <?xml version="1.0" encoding="utf-8"?>
    2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    3.     package="com.example.insert">
    4.  
    5.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    6.     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    7.     <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"/>
    8.     <application
    9.         android:requestLegacyExternalStorage="true"
    10.         android:allowBackup="true"
    11.         android:icon="@mipmap/ic_launcher"
    12.         android:label="@string/app_name"
    13.         android:roundIcon="@mipmap/ic_launcher_round"
    14.         android:supportsRtl="true"
    15.         android:theme="@style/Theme.Insert">
    16.         <activity
    17.             android:name=".MainActivity"
    18.             android:exported="true">
    19.             <intent-filter>
    20.                 <action android:name="android.intent.action.MAIN" />
    21.  
    22.                 <category android:name="android.intent.category.LAUNCHER" />
    23.             </intent-filter>
    24.         </activity>
    25.     </application>
    26.  
    27. </manifest>

    2.plugin_core

    定义一个Activity基类BaseActivity，继承AppCompatActivity并实现PluginActivityInterface接口。插件模块中的Activity类都继承该类，它是具体的Activity业务类的父类。

    BaseActivity中涉及到的生命周期函数重复了，如AppCompatActivity中的onCreate()方法与PluginActivityInterface接口中的onCreate()方法是重复的，这里在每个方法前面加上@SuppressLint("MissingSuperCall")注解，忽略该报错。
     

    1. public class BaseActivity extends AppCompatActivity implements PluginActivityInterface {
    2.  
    3.     private Activity proxyActivity; //注入的Activity，代理该Activity类作为上下文
    4.  
    5.     @Override
    6.  
    7.     public void attach(Activity proxyActivity) {
    8.  
    9.         this.proxyActivity = proxyActivity;  //注入代理Activity，在PluginActivity中将代理Activity组件注入进来
    10.  
    11.     }
    12.  
    13.     @Override
    14.  
    15.     public void setContentView(int layoutResID) {
    16.  
    17.         // 调用代理Activity中的setContentView方法
    18.  
    19.         if (proxyActivity != null) {
    20.  
    21.             proxyActivity.setContentView( layoutResID);
    22.  
    23.         }else{
    24.  
    25.             super.setContentView(layoutResID);
    26.  
    27.         }
    28.  
    29.     }
    30.  
    31.     @Override
    32.  
    33.     public void setContentView(View view) {
    34.  
    35.         if (proxyActivity != null) {
    36.  
    37.             proxyActivity.setContentView(view);
    38.  
    39.         }else{
    40.  
    41.             super.setContentView(view);
    42.  
    43.         }
    44.  
    45.     }
    46.  
    47.     @Override
    48.  
    49.     public extends View> T findViewById(int id){
    50.  
    51.         if (proxyActivity != null) {
    52.  
    53.             return proxyActivity.findViewById(id);
    54.  
    55.         }else{
    56.  
    57.             return super.findViewById(id);
    58.  
    59.         }
    60.  
    61.     }
    62.  
    63.     @Override
    64.  
    65.     public void startActivity(Intent intent) {
    66.  
    67.         if (proxyActivity != null) {
    68.  
    69.             intent.putExtra("className", intent.getComponent().getClassName());
    70.  
    71.             proxyActivity.startActivity(intent);
    72.  
    73.         }else{
    74.  
    75.             super.startActivity(intent);
    76.  
    77.         }
    78.  
    79.     }
    80.  
    81.     @SuppressLint("MissingSuperCall")
    82.  
    83.     @Override
    84.  
    85.     public void onCreate(Bundle savedInstanceState) {
    86.  
    87.     }
    88.  
    89.     @SuppressLint("MissingSuperCall")
    90.  
    91.     @Override
    92.  
    93.     public void onStart() {
    94.  
    95.     }
    96.  
    97.     @SuppressLint("MissingSuperCall")
    98.  
    99.     @Override
    100.  
    101.     public void onResume() {
    102.  
    103.     }
    104.  
    105.     @SuppressLint("MissingSuperCall")
    106.  
    107.     @Override
    108.  
    109.     public void onPause() {
    110.  
    111.     }
    112.  
    113.     @SuppressLint("MissingSuperCall")
    114.  
    115.     @Override
    116.  
    117.     public void onStop() {
    118.  
    119.     }
    120.  
    121.     @SuppressLint("MissingSuperCall")
    122.  
    123.     @Override
    124.  
    125.     public void onDestroy() {
    126.  
    127.     }
    128.  
    129.     @SuppressLint("MissingSuperCall")
    130.  
    131.     @Override
    132.  
    133.     public void onSaveInstanceState(Bundle outState) {
    134.  
    135.     }
    136.  
    137. }
    1. public interface PluginActivityInterface {
    2.     //绑定代理Activity
    3.  
    4.     void attach(Activity proxyActivity);
    5.  
    6.     void onCreate(Bundle savedInstanceState);
    7.  
    8.     void onStart();
    9.  
    10.     void onResume();
    11.  
    12.     void onPause();
    13.  
    14.     void onStop();
    15.  
    16.     void onDestroy();
    17.  
    18.     void onSaveInstanceState(Bundle outState);
    19.  
    20.     boolean onTouchEvent(MotionEvent event);
    21.  
    22.     void onBackPressed();
    23.  
    24. }
    1. public class PluginManager {
    2.  
    3.     private DexClassLoader mDexClassLoader;//类加载器，用于加载插件包apk中的classes.dex文件中的字节码对象
    4.  
    5.     private Resources mResources; //从插件包apk中加载的资源
    6.  
    7.     private PackageInfo mPackageInfo; //插件包信息类
    8.  
    9.     private Context mContext; //加载插件的上下文对象
    10.  
    11.     private static PluginManager instance;
    12.  
    13.     //获取单例类
    14.  
    15.     public static PluginManager getInstance(){
    16.  
    17.         if (instance == null) {
    18.  
    19.             instance = new PluginManager();
    20.  
    21.         }
    22.  
    23.         return instance;
    24.  
    25.     }
    26.  
    27.     // 加载插件，参数分别为加载插件的app的上下文、加载的插件包地址
    28.  
    29.     public void loadPlugin(Context context, String loadPath) {
    30.  
    31.         this.mContext = context;
    32.  
    33.         //DexClassLoader的optimizedDirectory目录必须是私有，即模式为Context.MODE_PRIVATE
    34.  
    35.         File optimizedDirectory = context.getDir( "cache_plugin", Context.MODE_PRIVATE);
    36.         Log.e("TAG",loadPath);
    37.  
    38.         mDexClassLoader = new DexClassLoader( loadPath, optimizedDirectory.getAbsolutePath(), null, context.getClassLoader()); // 创建类加载器
    39.  
    40.         // 加载资源
    41.  
    42.         try {
    43.  
    44.             AssetManager assetManager = AssetManager.class.newInstance(); //通过反射创建AssetManager
    45.  
    46.             Method addAssetPathMethod = assetManager.getClass().getDeclaredMethod("addAssetPath", String.class); //通过反射获取AssetManager中的addAssetPath隐藏方法
    47.  
    48.             addAssetPathMethod.invoke( assetManager, loadPath); //调用反射方法
    49.  
    50.             mResources = new Resources( assetManager, context.getResources().getDisplayMetrics(), context.getResources().getConfiguration()); //获取资源
    51.  
    52.             mPackageInfo = context.getPackageManager().getPackageArchiveInfo(loadPath, PackageManager.GET_ACTIVITIES); // 获取插件包中的Activity类信息
    53.  
    54.         } catch (Exception e) {
    55.             e.printStackTrace();
    56.  
    57.         }
    58.  
    59.     }
    60.  
    61.     //获取类加载器
    62.  
    63.     public DexClassLoader getmDexClassLoader(){
    64.  
    65.         return mDexClassLoader;
    66.  
    67.     }
    68.  
    69.     //获取插件包中的Package信息
    70.  
    71.     public PackageInfo getmPackageInfo() {
    72.  
    73.         return mPackageInfo;
    74.  
    75.     }
    76.  
    77.     //获取插件包中的资源
    78.  
    79.     public Resources getmResources() {
    80.  
    81.         return mResources;
    82.  
    83.     }
    84.  
    85. }

     

    在宿主apk中需要跳转到插件apk时，首先创建一个跳转到ProxyActivity(在核心库里)的intent，在intent中加上插件apk的入口activity。这样ProxyActivity作为代理Activity ，它持有从插件apk中加载的PluginActivity类对象。

    ProxyActivity是空的Activity，没有任何实际的业务逻辑，只是作为一个生命周期的转接代理接口。但是ProxyActivity有着完整的生命周期回调机制，在进入该界面时会回调onCreate、onStart、onResume生命周期方法，在退出该界面时会回调 onPause、onStop、onDestroy生命周期方法。因此只需要在ProxyActivity的生命周期方法中，调用PluginActivity相应的生命周期方法即可。而且ProxyActivity运行时会有上下文，PluginActivity使用上下文时调用ProxyActivity的上下文。
    注意：插件模块的包名可以和宿主的包名一样也可以不一样。当插件apk的包名和宿主一样时，要注意插件apk里的Activity名字一定不要和宿主apk中Activity的名字一样，否则包名和Activity名都一样就无法跳转到插件Activity了。

    1. //该Activity只是个空壳，主要用于持有从插件apk加载的Activity类，并在ProxyActivity生命周期方法中调用对应PluginActivity类的生命周期方法
    2.  
    3. public class ProxyActivity extends Activity {
    4.  
    5.     private String className = ""; //被代理的目标Activity组件的全类名
    6.  
    7.     private PluginActivityInterface pluginActivity;//插件包中的Activity界面组件
    8.  
    9.     @Override
    10.  
    11.     protected void onCreate(Bundle savedInstanceState) {
    12.  
    13.         super.onCreate(savedInstanceState);
    14.  
    15.         setContentView(R.layout.activity_proxy);
    16.  
    17.         className = getIntent().getStringExtra("className"); //得到要代理的目标组件的全类名，即插件apk中的入口activity的全类名
    18.  
    19.         try {
    20.  
    21.             Class clazz = getClassLoader().loadClass(
    22.                     className); //使用类加载器加载插件中的界面组件。注意这里类加载器必须是PluginManager中的类加载器，即getClassLoader()是重写的方法，该方法返回PluginManager中的类加载器
    23.  
    24.             Activity activity = (Activity) clazz.newInstance(); //使用反射创建插件apk中的Activity
    25.  
    26.             if (activity instanceof PluginActivityInterface) { // 判断Activity组件是否是PluginActivityInterface接口类型的
    27.  
    28.                 this.pluginActivity =
    29.                         (PluginActivityInterface) activity; // 如果是PluginActivityInterface类型 , 则强转为该类型
    30.  
    31.                 pluginActivity.attach(
    32.                         this);  // 上下文注入。将ProxyActivity绑定注入到插件包的PluginActivity类中。该ProxyActivity具有运行的上下文，一旦绑定注入成功，则被代理的PluginActivity也具有了上下文
    33.  
    34.                 pluginActivity.onCreate(savedInstanceState);  //调用pluginActivity的onCreate生命周期
    35.  
    36.             }
    37.  
    38.         } catch (Exception e) {
    39.  
    40.             e.printStackTrace();
    41.  
    42.         }
    43.  
    44.     }
    45.  
    46.     @Override
    47.  
    48.     protected void onStart() {
    49.  
    50.         super.onStart();
    51.  
    52.         pluginActivity.onStart();
    53.  
    54.     }
    55.  
    56.     @Override
    57.  
    58.     protected void onResume() {
    59.  
    60.         super.onResume();
    61.  
    62.         pluginActivity.onResume();
    63.  
    64.     }
    65.  
    66.     @Override
    67.  
    68.     protected void onPause() {
    69.  
    70.         super.onPause();
    71.  
    72.         pluginActivity.onPause();
    73.  
    74.     }
    75.  
    76.     @Override
    77.  
    78.     protected void onStop() {
    79.  
    80.         super.onStop();
    81.  
    82.         pluginActivity.onStop();
    83.  
    84.     }
    85.  
    86.     @Override
    87.  
    88.     protected void onDestroy() {
    89.  
    90.         super.onDestroy();
    91.  
    92.         pluginActivity.onDestroy();
    93.  
    94.     }
    95.  
    96.     @Override
    97.  
    98.     protected void onSaveInstanceState(Bundle outState) {
    99.  
    100.         super.onSaveInstanceState(outState);
    101.  
    102.         pluginActivity.onSaveInstanceState(outState);
    103.  
    104.     }
    105.  
    106.     @Override
    107.  
    108.     public boolean onTouchEvent(MotionEvent event) {
    109.  
    110.         super.onTouchEvent(event);
    111.  
    112.         return pluginActivity.onTouchEvent(event);
    113.  
    114.     }
    115.  
    116.     @Override
    117.  
    118.     public void onBackPressed() {
    119.  
    120.         //super.onBackPressed();
    121.  
    122.         //pluginActivity.onBackPressed();
    123.  
    124.         finish();
    125.  
    126.     }
    127.  
    128.     //重写getClassLoader方法，因为这里需要使用插件包加载的类加载器
    129.  
    130.     @Override
    131.  
    132.     public ClassLoader getClassLoader() {
    133.  
    134.         return PluginManager.getInstance().getmDexClassLoader();
    135.  
    136.     }
    137.  
    138.     //重写getResources方法，因为这里需要使用插件包加载的资源
    139.  
    140.     @Override
    141.  
    142.     public Resources getResources() {
    143.  
    144.         return PluginManager.getInstance().getmResources();
    145.  
    146.     }
    147. }

     

    1. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    2.     package="com.example.plugin_core">
    3.     <application>
    4.         <activity android:name=".ProxyActivity"/>
    5.     </application>
    6.  
    7. </manifest>

    3.plugin

    1. <?xml version="1.0" encoding="utf-8"?>
    2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    3.     package="com.example.plugin">
    4.  
    5.     <application
    6.         android:allowBackup="true"
    7.         android:icon="@mipmap/ic_launcher"
    8.         android:label="@string/app_name"
    9.         android:roundIcon="@mipmap/ic_launcher_round"
    10.         android:supportsRtl="true"
    11.         android:theme="@style/Theme.Insert">
    12.         <activity
    13.             android:name=".PluginActivity"
    14.             android:exported="true">
    15.         </activity>
    16.     </application>
    17.  
    18. </manifest>

     

    所有的插件包中的Activity都要继承 BaseActivity。

    这样写的目的是为了方便在代理Activity中可以随意调用插件apk中的Activity类的生命周期函数，这些生命周期函数都是protected方法，不能直接调用，否则每个方法调用时，还要先反射修改访问性，才能调用
     

    1. public class PluginActivity extends BaseActivity {
    2.  
    3.     @Override
    4.     public void onCreate(Bundle savedInstanceState) {
    5.         super.onCreate(savedInstanceState);
    6.         setContentView(R.layout.activity_main);
    7.     }
    8. }

    代码完成，接下来看如何运行：

    ①首先编译插件模块，生成插件apk安装包:

    ②拷贝插件apk

    将编译的插件包apk拷贝到 /storage/emulated/0/Android/data/com.example.insert/files目录中。在 " Device FIle Explorer " 面板中 , 右键点击/storage/emulated/0/DCIM目录 , 点击"Upload " 即可将apk上传到指定位置。

    ③运行宿主模块，在onCreate方法中就会加载解析插件apk，解析dex文件与资源文件。此时点击跳转按钮，即可跳转到插件模块Activity中。
     

  • 相关阅读:
    【神印王座】两位新老婆登场！龙皓晨神勇救美，采儿却大发醋意！
    systemctl教程（systemctl命令）（systemd）（service命令）
    MYSQL进阶
    前端 js面试题（二）
    小程序使用uni.createAnimation只执行一次的问题
    Allegro批量剪断走线操作
    迅为RK3568开发板驱动指南第六篇-平台总线
    ES6汇总
    向着趋势奔跑：银行客户中心转型，重构商业模式是关键
    构建高效问题解答平台：使用Cpolar和Tipas在Ubuntu上搭建专属问答网站
  • 原文地址：https://blog.csdn.net/xiaowang_lj/article/details/128081889