Android MultiDex初次启动APP优化方案优雅的实现

在开始本篇文章之前,强烈建议不熟悉MultiDex以及坑点的童鞋看两篇文章:

简单来说,安装完成并初次启动APP的时候,5.0以下某些低端机会出现ANR或者长时间卡顿不进入引导页,而罪魁祸首是MultiDex.install(Context context)的dexopt过程耗时过长。因此需要在初次启动时做特别处理。

解决这个问题的思路以及详细解释,大致分为3步:

  • Application.attachBaseContext(Context base)中,判断是否初次启动,以及系统版本是否小于5.0,如果是,跳到2;否则,直接执行MultiDex.install(Context context)
  • 开启一个新进程,在这个进程中执行MultiDex.install(Context context)。执行完毕,唤醒主进程,自身结束。主进程在开启新进程后,自身是挂起的,直到被唤醒。
  • 唤醒的主进程继续执行初始化操作。

这个解决思路对现有代码几乎是没有改动的,并且简单粗暴:既然不能直接调用MultiDex.install(Context context),那么干脆开启新进程调用,因为开启新进程时,主进程已经成为后台进程,即使挂起也不会ANR。
开启新进程加载太麻烦,能不能开新线程加载,而主线程继续Application初始化?显然不行。因为multidex安装没有结束,意味着dex还没加载进来,某些类强行使用就会报NoClassDefFoundError

方案中有一个小难点是:主进程如何得知加载进程完成加载?我们使用标记来记录。MODE_MULTI_PROCESS标记使得SharedPreference得以进程间共享,主进程轮询sp文件即可。但是,这个标记在6.0被废除,Google不保证行为的准确性。而且……我们有一万个理由,能不写轮询就不写。那么我们该如何优雅的实现呢?没错,今天我们使用Messenger的方式来实现:

话不多说,直接上终极版解决代码: (对于原理和解决思路不清晰的可以查看我的其他两篇文章)
BaseApplication.class

public abstract class BaseApplication extends Application{

    @SuppressWarnings("MismatchedReadAndWriteOfArray")
    private static final byte[] lock = new byte[0];

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        //Android 5.0以上不需要特别处理
        if (!isAsyncLaunchProcess() && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            if (needWait(base)) {
                /*
                    第一次启动APP由于MultiDex将会非常缓慢,某些低端机可能ANR。
                    因此这里的做法是挂起主进程,开启:async_launch进程执行dexopt。
                    dexopt执行完毕,主进程重新变为前台进程,继续执行初始化。
                    主进程在这过程中变成后台进程,因此阻塞将不会引起ANR。
                 */
                DexInstallDeamonThread thread = new DexInstallDeamonThread(this, base);
                thread.start();

                //阻塞等待:async_launch完成加载
                synchronized (lock) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                thread.exit();
                Log.d("BaseApplication", "dexopt finished. alloc MultiDex.install()");
            } else {
                MultiDex.install(this);
            }
        }
    }

    public boolean isAsyncLaunchProcess() {
        String processName = SystemUtils.getCurrentProcessName(this);
        return processName != null && processName.contains(":async_launch");
    }

    @SuppressWarnings("deprecation")
    private boolean needWait(Context context) {
        //这里实现不唯一,读取一个全局的标记,判断是否初次启动APP
        //这个标记应当随着版本升级而重置
        SharedPreferences sp = SPUtils.getVersionSharedPreferences(context);
        return sp.getBoolean(BaseSPKey.FIRST_LAUNCH, true);
    }

    private static class DexInstallDeamonThread extends Thread {

        private Handler handler;

        private Context application;

        private Context base;

        private Looper looper;

        public DexInstallDeamonThread(Context application, Context base) {
            this.application = application;
            this.base = base;
        }

        @SuppressLint("HandlerLeak")
        @Override
        public void run() {
            Looper.prepare();
            looper = Looper.myLooper();
            handler = new Handler() {

                @SuppressWarnings("deprecation")
                @Override
                public void handleMessage(Message msg) {
                    synchronized (lock) {
                        lock.notify();
                    }
                    SPUtils
                        .getVersionSharedPreferences(application)
                        .edit()
                        .putBoolean(BaseSPKey.FIRST_LAUNCH, false)
                        .apply();
                }
            };

            Messenger messenger = new Messenger(handler);
            Intent intent = new Intent(base, LoadResActivity.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            intent.putExtra("MESSENGER", messenger);
            base.startActivity(intent);
            Looper.loop();
        }

        public void exit() {
            if (looper != null) looper.quit();
        }
    }
}

LoadResActivity.class

public class LoadResActivity extends AppCompatActivity {

    private Messenger messenger;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        super.onCreate(savedInstanceState);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        overridePendingTransition(R.anim.null_anim, R.anim.null_anim);
        setContentView(R.layout.activity_load_res);

        Log.d("LoadResActivity", "start install");
        Intent from = getIntent();
        messenger = from.getParcelableExtra("MESSENGER");

        LoadDexTask dexTask = new LoadDexTask();
        dexTask.execute();
    }

    class LoadDexTask extends AsyncTask<Void, Void, Void> {

        @Override
        protected Void doInBackground(Void... params) {
            try {
                MultiDex.install(getApplication());
                Log.d("LoadResActivity", "finish install");
                messenger.send(new Message());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void o) {
            finish();
            System.exit(0);
        }
    }

    @Override
    public void onBackPressed() {
        //无法退出
    }
}

app/AndroidManifest.xml加入:

<activity
    android:name="com.synaric.dex.LoadResActivity"
    android:launchMode= "singleTask"
    android:alwaysRetainTaskState= "false"
    android:excludeFromRecents= "true"
    android:screenOrientation= "portrait"
    android:process=":async_launch"/>

SystemUtils.class

public class SystemUtils {

    //...

    /**
     * 获取当前进程名。
     */
    public static String getCurrentProcessName(Context context) {
        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        if (activityManager == null) {
            return null;
        }
        for (ActivityManager.RunningAppProcessInfo processInfo : activityManager.getRunningAppProcesses()) {
            if (processInfo.pid == Process.myPid()) {
                return processInfo.processName;
            }
        }
        return null;
    }
}

最后,因为有大量代码在install之前执行,因此必须把代码中用到的类放到主dex中(需要build tool版本大于21):

app/build.gradle

android {

    //...

    defaultConfig {
        //...

        //定义main dex中必须保留的类
        multiDexKeepProguard file('mainDexClasses.pro')
    }
}

app/mainDexClasses.pro

#这里只是示例,需要把所有install之前用到的类写进来

-keep public class * extends java.lang.Thread { *; }

-keep public class com.synaric.common.utils.SystemUtils { *; }

-keep public class com.synaric.common.utils.SPUtils { *; }

-keep interface android.content.SharedPreferences { *; }

-keep class android.os.Handler { *; }

-keep class com.synaric.common.BaseSPKey { *; }

-keep class android.os.Messenger { *; }

-keep class android.content.Intent { *; }

总结:以上就是通过Messenger的方式实现的dex的分包加载啦~ 这种方式对安卓系统的版本没有限制, 因此是最优雅的实现方式。至此,MultiDex使用爬坑就告一段落了, 希望能对大家有帮助。

推荐阅读更多精彩内容