Android MultiDex初次启动APP优化

最新推荐文章于 2024-06-26 15:40:41 发布

Synaric

最新推荐文章于 2024-06-26 15:40:41 发布

阅读量1w

点赞数

分类专栏：踩坑文章标签： android app 优化

本文链接：https://blog.csdn.net/synaric/article/details/53540760

版权

踩坑专栏收录该内容

5 篇文章 0 订阅

订阅专栏

在开始文章之前，强烈建议不熟悉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 { *; }