修改问题

app/build.gradle

@@ -123,6 +123,6 @@ dependencies {
     implementation 'com.applovin.mediation:facebook-adapter:+'
     implementation 'com.applovin.mediation:mintegral-adapter:+'
     implementation 'com.applovin.mediation:bytedance-adapter:+'
-    implementation("com.blankj:utilcodex:1.31.1")
+
 
 }
\ No newline at end of file

app/src/main/java/com/test/easy/easycleanerjunk/MyApplication.kt

 package com.test.easy.easycleanerjunk
 
 import android.app.Activity
-import android.app.Application
 import android.content.Intent
 import android.os.Bundle
 import android.text.TextUtils
@@ -19,13 +18,13 @@ import com.test.easy.easycleanerjunk.helps.ConfigHelper
 import com.test.easy.easycleanerjunk.helps.InstallHelps
 import com.test.easy.easycleanerjunk.helps.ads.AdmobUtils
 import com.test.easy.easycleanerjunk.helps.ads.MaxAdUtils
+import com.test.easy.easycleanerjunk.utils.ActivityManagerUtils
 import com.test.easy.easycleanerjunk.utils.SPUtils
-import com.test.easy.easycleanerjunk.utils.UtilsBridge
 import java.util.UUID
 import java.util.concurrent.Executors
 
 
-class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks {
+class MyApplication : BaseApplication() {
 
     companion object {
         @JvmField
@@ -34,9 +33,10 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
 
     var uuid = ""
     override fun init() {
-        registerActivityLifecycleCallbacks(this)
+       // registerActivityLifecycleCallbacks(this)
         initUUid()
         initApp()
+
     }
 
     private fun initUUid() {
@@ -75,9 +75,8 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
         }
         BlackUtils.requestBlack()
         if (ConfigHelper.ifAgreePrivacy) {
-
-
         }
+        initLifeListener()
     }
 
     private fun initNotificationWork() {
@@ -89,86 +88,170 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
 
         ActionBroadcast.initBroadcast(this)
     }
-
-    private var count = 0
-    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
-        Log.e("MXL", "onActivityCreated: "+activity.localClassName )
+    private var lastTimePause = 0L
+    private var lastTimeResume = 0L
+    private fun isHotLaunch(): Boolean {
+        if ((lastTimeResume - lastTimePause) > 1000) {
+            return true
+        }
+        return false
     }
+    private fun initLifeListener() {
+        registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
+            private var count = 0
+            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+                ActivityManagerUtils.getInstance().addActivity(activity)
+            }
 
-    override fun onActivityStarted(activity: Activity) {
-        count++
-        lastTimeResume = System.currentTimeMillis()
-        if (count == 1 && isHotLaunch()) {
+            override fun onActivityStarted(activity: Activity) {
+                count++
+                lastTimeResume = System.currentTimeMillis()
+                if (count == 1 && isHotLaunch()) {
 
-            //val topActivity: Activity? = ActivityManagerUtils.getInstance().topActivity
-            val topActivity= UtilsBridge.getTopActivity()
-            var flag = if (topActivity == null) {
-                true
-            } else {
-                ConfigHelper.noLoadingActivities
-                    .all { !topActivity.localClassName.contains(it, true) }
-            }
-            if (activity.localClassName.contains("AppLovinFullscreenActivity")) {
-                flag = false
-            }
-            if (flag) {
-                if (ConfigHelper.admobTrueMaxFlase == 0) {
-                    if (MaxAdUtils.isOpenAdLoaded()) {
-                        MaxAdUtils.showAppOpenAd(activity)
+                    val topActivity: Activity? = ActivityManagerUtils.getInstance().topActivity
+
+                    var flag = if (topActivity == null) {
+                        true
                     } else {
-                        topActivity?.startActivity(
-                            Intent(
-                                topActivity,
-                                NewSplashActivity::class.java
-                            ).apply {
-                                putExtra("isHotLaunch", true)
-                                putExtra("type", -1)
-                            })
+                        ConfigHelper.noLoadingActivities
+                            .all { !topActivity.localClassName.contains(it, true) }
                     }
-                } else {
-                    if (AdmobUtils.isOpenAdLoaded()) {
-                        AdmobUtils.showAppOpenAd(activity)
-                    } else {
-                        topActivity?.startActivity(
-                            Intent(
-                                topActivity,
-                                NewSplashActivity::class.java
-                            ).apply {
-                                putExtra("isHotLaunch", true)
-                                putExtra("type", -1)
-                            })
+                    if (activity.localClassName.contains("AppLovinFullscreenActivity")) {
+                        flag = false
                     }
-                }
+                    if (flag) {
+                        if(ConfigHelper.admobTrueMaxFlase==0){
+                            if (MaxAdUtils.isOpenAdLoaded()) {
+                                MaxAdUtils.showAppOpenAd(activity)
+                            } else {
+                                topActivity?.startActivity(
+                                    Intent(
+                                        topActivity,
+                                        NewSplashActivity::class.java
+                                    ).apply {
+                                        putExtra("isHotLaunch", true)
+                                        putExtra("type", -1)
+                                    })
+                            }
+                        }else{
+                            if (AdmobUtils.isOpenAdLoaded()) {
+                                AdmobUtils.showAppOpenAd(activity)
+                            } else {
+                                topActivity?.startActivity(
+                                    Intent(
+                                        topActivity,
+                                        NewSplashActivity::class.java
+                                    ).apply {
+                                        putExtra("isHotLaunch", true)
+                                        putExtra("type", -1)
+                                    })
+                            }
+                        }
 
+                    }
+                }
             }
-        }
-    }
-
-    override fun onActivityResumed(activity: Activity) {
-        PAUSED_VALUE = 1
-    }
 
+            override fun onActivityResumed(activity: Activity) {
+                PAUSED_VALUE = 1
+            }
 
-    override fun onActivityPaused(activity: Activity) {
-        PAUSED_VALUE = 2
-        lastTimePause = System.currentTimeMillis()
 
-    }
+            override fun onActivityPaused(activity: Activity) {
+                PAUSED_VALUE = 2
+                lastTimePause = System.currentTimeMillis()
+                Log.d("glc", "PAUSED_VALUE:" + PAUSED_VALUE)
 
-    override fun onActivityStopped(activity: Activity) {
-        count--
-    }
+            }
 
-    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+            override fun onActivityStopped(activity: Activity) {
+                count--
+            }
 
-    override fun onActivityDestroyed(activity: Activity) {}
+            override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
 
-    private var lastTimePause = 0L
-    private var lastTimeResume = 0L
-    private fun isHotLaunch(): Boolean {
-        if ((lastTimeResume - lastTimePause) > 1000) {
-            return true
-        }
-        return false
+            override fun onActivityDestroyed(activity: Activity) {}
+        })
     }
+
+//    private var count = 0
+//    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+//        ActivityManagerUtils.getInstance().addActivity(activity)
+//    }
+//
+//    override fun onActivityStarted(activity: Activity) {
+//        count++
+//        lastTimeResume = System.currentTimeMillis()
+//        if (count == 1 && isHotLaunch()) {
+//
+//            val topActivity: Activity? = ActivityManagerUtils.getInstance().topActivity
+//            var flag = if (topActivity == null) {
+//                true
+//            } else {
+//                ConfigHelper.noLoadingActivities
+//                    .all { !topActivity.localClassName.contains(it, true) }
+//            }
+//            if (activity.localClassName.contains("AppLovinFullscreenActivity")) {
+//                flag = false
+//            }
+//            if (flag) {
+//                if (ConfigHelper.admobTrueMaxFlase == 0) {
+//                    if (MaxAdUtils.isOpenAdLoaded()) {
+//                        MaxAdUtils.showAppOpenAd(activity)
+//                    } else {
+//                        topActivity?.startActivity(
+//                            Intent(
+//                                topActivity,
+//                                NewSplashActivity::class.java
+//                            ).apply {
+//                                putExtra("isHotLaunch", true)
+//                                putExtra("type", -1)
+//                            })
+//                    }
+//                } else {
+//                    if (AdmobUtils.isOpenAdLoaded()) {
+//                        AdmobUtils.showAppOpenAd(activity)
+//                    } else {
+//                        topActivity?.startActivity(
+//                            Intent(
+//                                topActivity,
+//                                NewSplashActivity::class.java
+//                            ).apply {
+//                                putExtra("isHotLaunch", true)
+//                                putExtra("type", -1)
+//                            })
+//                    }
+//                }
+//
+//            }
+//        }
+//    }
+//
+//    override fun onActivityResumed(activity: Activity) {
+//        PAUSED_VALUE = 1
+//    }
+//
+//
+//    override fun onActivityPaused(activity: Activity) {
+//        PAUSED_VALUE = 2
+//        lastTimePause = System.currentTimeMillis()
+//
+//    }
+//
+//    override fun onActivityStopped(activity: Activity) {
+//        count--
+//    }
+//
+//    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+//
+//    override fun onActivityDestroyed(activity: Activity) {}
+//
+//    private var lastTimePause = 0L
+//    private var lastTimeResume = 0L
+//    private fun isHotLaunch(): Boolean {
+//        if ((lastTimeResume - lastTimePause) > 1000) {
+//            return true
+//        }
+//        return false
+//    }
 }
\ No newline at end of file

app/src/main/java/com/test/easy/easycleanerjunk/utils/UtilsActivityLifecycleImpl.java

-package com.test.easy.easycleanerjunk.utils;
-
-import android.animation.ValueAnimator;
-import android.app.Activity;
-import android.app.Application;
-import android.os.Build;
-import android.os.Bundle;
-import android.util.Log;
-import android.view.Window;
-import android.view.WindowManager;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.lifecycle.Lifecycle;
-
-import com.blankj.utilcode.util.Utils;
-
-import java.lang.reflect.Field;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.CopyOnWriteArrayList;
-
-public class UtilsActivityLifecycleImpl implements Application.ActivityLifecycleCallbacks {
-
-    static final UtilsActivityLifecycleImpl INSTANCE = new UtilsActivityLifecycleImpl();
-
-    private final LinkedList<Activity> mActivityList = new LinkedList<>();
-
-    private final List<Utils.OnAppStatusChangedListener> mStatusListeners               = new CopyOnWriteArrayList<>();
-    private final Map<Activity, List<Utils.ActivityLifecycleCallbacks>> mActivityLifecycleCallbacksMap = new ConcurrentHashMap<>();
-
-    private static final Activity STUB = new Activity();
-
-    private int     mForegroundCount = 0;
-    private int     mConfigCount     = 0;
-    private boolean mIsBackground    = false;
-
-    void init(Application app) {
-        app.registerActivityLifecycleCallbacks(this);
-    }
-
-    void unInit(Application app) {
-        mActivityList.clear();
-        app.unregisterActivityLifecycleCallbacks(this);
-    }
-
-    Activity getTopActivity() {
-        List<Activity> activityList = getActivityList();
-        for (Activity activity : activityList) {
-            if (!UtilsBridge.isActivityAlive(activity)) {
-                continue;
-            }
-            return activity;
-        }
-        return null;
-    }
-
-    List<Activity> getActivityList() {
-        if (!mActivityList.isEmpty()) {
-            return new LinkedList<>(mActivityList);
-        }
-        List<Activity> reflectActivities = getActivitiesByReflect();
-        mActivityList.addAll(reflectActivities);
-        return new LinkedList<>(mActivityList);
-    }
-
-    void addOnAppStatusChangedListener(final Utils.OnAppStatusChangedListener listener) {
-        mStatusListeners.add(listener);
-    }
-
-    void removeOnAppStatusChangedListener(final Utils.OnAppStatusChangedListener listener) {
-        mStatusListeners.remove(listener);
-    }
-
-    void addActivityLifecycleCallbacks(final Utils.ActivityLifecycleCallbacks listener) {
-        addActivityLifecycleCallbacks(STUB, listener);
-    }
-
-    void addActivityLifecycleCallbacks(final Activity activity,
-                                       final Utils.ActivityLifecycleCallbacks listener) {
-        if (activity == null || listener == null) return;
-        UtilsBridge.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                addActivityLifecycleCallbacksInner(activity, listener);
-            }
-        });
-    }
-
-    boolean isAppForeground() {
-        return !mIsBackground;
-    }
-
-    private void addActivityLifecycleCallbacksInner(final Activity activity,
-                                                    final Utils.ActivityLifecycleCallbacks callbacks) {
-        List<Utils.ActivityLifecycleCallbacks> callbacksList = mActivityLifecycleCallbacksMap.get(activity);
-        if (callbacksList == null) {
-            callbacksList = new CopyOnWriteArrayList<>();
-            mActivityLifecycleCallbacksMap.put(activity, callbacksList);
-        } else {
-            if (callbacksList.contains(callbacks)) return;
-        }
-        callbacksList.add(callbacks);
-    }
-
-    void removeActivityLifecycleCallbacks(final Utils.ActivityLifecycleCallbacks callbacks) {
-        removeActivityLifecycleCallbacks(STUB, callbacks);
-    }
-
-    void removeActivityLifecycleCallbacks(final Activity activity) {
-        if (activity == null) return;
-        UtilsBridge.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                mActivityLifecycleCallbacksMap.remove(activity);
-            }
-        });
-    }
-
-    void removeActivityLifecycleCallbacks(final Activity activity,
-                                          final Utils.ActivityLifecycleCallbacks callbacks) {
-        if (activity == null || callbacks == null) return;
-        UtilsBridge.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                removeActivityLifecycleCallbacksInner(activity, callbacks);
-            }
-        });
-    }
-
-    private void removeActivityLifecycleCallbacksInner(final Activity activity,
-                                                       final Utils.ActivityLifecycleCallbacks callbacks) {
-        List<Utils.ActivityLifecycleCallbacks> callbacksList = mActivityLifecycleCallbacksMap.get(activity);
-        if (callbacksList != null && !callbacksList.isEmpty()) {
-            callbacksList.remove(callbacks);
-        }
-    }
-
-    private void consumeActivityLifecycleCallbacks(Activity activity, Lifecycle.Event event) {
-        consumeLifecycle(activity, event, mActivityLifecycleCallbacksMap.get(activity));
-        consumeLifecycle(activity, event, mActivityLifecycleCallbacksMap.get(STUB));
-    }
-
-    private void consumeLifecycle(Activity activity, Lifecycle.Event event, List<Utils.ActivityLifecycleCallbacks> listeners) {
-        if (listeners == null) return;
-        for (Utils.ActivityLifecycleCallbacks listener : listeners) {
-            listener.onLifecycleChanged(activity, event);
-            if (event.equals(Lifecycle.Event.ON_CREATE)) {
-                listener.onActivityCreated(activity);
-            } else if (event.equals(Lifecycle.Event.ON_START)) {
-                listener.onActivityStarted(activity);
-            } else if (event.equals(Lifecycle.Event.ON_RESUME)) {
-                listener.onActivityResumed(activity);
-            } else if (event.equals(Lifecycle.Event.ON_PAUSE)) {
-                listener.onActivityPaused(activity);
-            } else if (event.equals(Lifecycle.Event.ON_STOP)) {
-                listener.onActivityStopped(activity);
-            } else if (event.equals(Lifecycle.Event.ON_DESTROY)) {
-                listener.onActivityDestroyed(activity);
-            }
-        }
-        if (event.equals(Lifecycle.Event.ON_DESTROY)) {
-            mActivityLifecycleCallbacksMap.remove(activity);
-        }
-    }
-
-    Application getApplicationByReflect() {
-        try {
-            Class activityThreadClass = Class.forName("android.app.ActivityThread");
-            Object thread = getActivityThread();
-            if (thread == null) return null;
-            Object app = activityThreadClass.getMethod("getApplication").invoke(thread);
-            if (app == null) return null;
-            return (Application) app;
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // lifecycle start
-    ///////////////////////////////////////////////////////////////////////////
-    @Override
-    public void onActivityPreCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {/**/}
-
-    @Override
-    public void onActivityCreated(@NonNull Activity activity, Bundle savedInstanceState) {
-        if (mActivityList.size() == 0) {
-            postStatus(activity, true);
-        }
-        setAnimatorsEnabled();
-        setTopActivity(activity);
-        consumeActivityLifecycleCallbacks(activity, Lifecycle.Event.ON_CREATE);
-    }
-
-    @Override
-    public void onActivityPostCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {/**/}
-
-    @Override
-    public void onActivityPreStarted(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityStarted(@NonNull Activity activity) {
-        if (!mIsBackground) {
-            setTopActivity(activity);
-        }
-        if (mConfigCount < 0) {
-            ++mConfigCount;
-        } else {
-            ++mForegroundCount;
-        }
-        consumeActivityLifecycleCallbacks(activity, Lifecycle.Event.ON_START);
-    }
-
-    @Override
-    public void onActivityPostStarted(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityPreResumed(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityResumed(@NonNull final Activity activity) {
-        setTopActivity(activity);
-        if (mIsBackground) {
-            mIsBackground = false;
-            postStatus(activity, true);
-        }
-        processHideSoftInputOnActivityDestroy(activity, false);
-        consumeActivityLifecycleCallbacks(activity, Lifecycle.Event.ON_RESUME);
-    }
-
-    @Override
-    public void onActivityPostResumed(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityPrePaused(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityPaused(@NonNull Activity activity) {
-        consumeActivityLifecycleCallbacks(activity, Lifecycle.Event.ON_PAUSE);
-    }
-
-    @Override
-    public void onActivityPostPaused(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityPreStopped(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityStopped(Activity activity) {
-        if (activity.isChangingConfigurations()) {
-            --mConfigCount;
-        } else {
-            --mForegroundCount;
-            if (mForegroundCount <= 0) {
-                mIsBackground = true;
-                postStatus(activity, false);
-            }
-        }
-        processHideSoftInputOnActivityDestroy(activity, true);
-        consumeActivityLifecycleCallbacks(activity, Lifecycle.Event.ON_STOP);
-    }
-
-    @Override
-    public void onActivityPostStopped(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityPreSaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {/**/}
-
-    @Override
-    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {/**/}
-
-    @Override
-    public void onActivityPostSaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {/**/}
-
-    @Override
-    public void onActivityPreDestroyed(@NonNull Activity activity) {/**/}
-
-    @Override
-    public void onActivityDestroyed(@NonNull Activity activity) {
-        mActivityList.remove(activity);
-        UtilsBridge.fixSoftInputLeaks(activity);
-        consumeActivityLifecycleCallbacks(activity, Lifecycle.Event.ON_DESTROY);
-    }
-
-    @Override
-    public void onActivityPostDestroyed(@NonNull Activity activity) {/**/}
-    ///////////////////////////////////////////////////////////////////////////
-    // lifecycle end
-    ///////////////////////////////////////////////////////////////////////////
-
-    /**
-     * To solve close keyboard when activity onDestroy.
-     * The preActivity set windowSoftInputMode will prevent
-     * the keyboard from closing when curActivity onDestroy.
-     */
-    private void processHideSoftInputOnActivityDestroy(final Activity activity, boolean isSave) {
-        try {
-            if (isSave) {
-                Window window = activity.getWindow();
-                final WindowManager.LayoutParams attrs = window.getAttributes();
-                final int softInputMode = attrs.softInputMode;
-                window.getDecorView().setTag(-123, softInputMode);
-                window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
-            } else {
-                final Object tag = activity.getWindow().getDecorView().getTag(-123);
-                if (!(tag instanceof Integer)) return;
-                UtilsBridge.runOnUiThreadDelayed(new Runnable() {
-                    @Override
-                    public void run() {
-                        try {
-                            Window window = activity.getWindow();
-                            if (window != null) {
-                                window.setSoftInputMode(((Integer) tag));
-                            }
-                        } catch (Exception ignore) {
-                        }
-                    }
-                }, 100);
-            }
-        } catch (Exception ignore) {
-        }
-    }
-
-    private void postStatus(final Activity activity, final boolean isForeground) {
-        if (mStatusListeners.isEmpty()) return;
-        for (Utils.OnAppStatusChangedListener statusListener : mStatusListeners) {
-            if (isForeground) {
-                statusListener.onForeground(activity);
-            } else {
-                statusListener.onBackground(activity);
-            }
-        }
-    }
-
-    private void setTopActivity(final Activity activity) {
-        if (mActivityList.contains(activity)) {
-            if (!mActivityList.getFirst().equals(activity)) {
-                mActivityList.remove(activity);
-                mActivityList.addFirst(activity);
-            }
-        } else {
-            mActivityList.addFirst(activity);
-        }
-    }
-
-    /**
-     * @return the activities which topActivity is first position
-     */
-    private List<Activity> getActivitiesByReflect() {
-        LinkedList<Activity> list = new LinkedList<>();
-        Activity topActivity = null;
-        try {
-            Object activityThread = getActivityThread();
-            if (activityThread == null) return list;
-            Field mActivitiesField = activityThread.getClass().getDeclaredField("mActivities");
-            mActivitiesField.setAccessible(true);
-            Object mActivities = mActivitiesField.get(activityThread);
-            if (!(mActivities instanceof Map)) {
-                return list;
-            }
-            Map<Object, Object> binder_activityClientRecord_map = (Map<Object, Object>) mActivities;
-            for (Object activityRecord : binder_activityClientRecord_map.values()) {
-                Class activityClientRecordClass = activityRecord.getClass();
-                Field activityField = activityClientRecordClass.getDeclaredField("activity");
-                activityField.setAccessible(true);
-                Activity activity = (Activity) activityField.get(activityRecord);
-                if (topActivity == null) {
-                    Field pausedField = activityClientRecordClass.getDeclaredField("paused");
-                    pausedField.setAccessible(true);
-                    if (!pausedField.getBoolean(activityRecord)) {
-                        topActivity = activity;
-                    } else {
-                        list.addFirst(activity);
-                    }
-                } else {
-                    list.addFirst(activity);
-                }
-            }
-        } catch (Exception e) {
-            Log.e("UtilsActivityLifecycle", "getActivitiesByReflect: " + e.getMessage());
-        }
-        if (topActivity != null) {
-            list.addFirst(topActivity);
-        }
-        return list;
-    }
-
-    private Object getActivityThread() {
-        Object activityThread = getActivityThreadInActivityThreadStaticField();
-        if (activityThread != null) return activityThread;
-        return getActivityThreadInActivityThreadStaticMethod();
-    }
-
-    private Object getActivityThreadInActivityThreadStaticField() {
-        try {
-            Class activityThreadClass = Class.forName("android.app.ActivityThread");
-            Field sCurrentActivityThreadField = activityThreadClass.getDeclaredField("sCurrentActivityThread");
-            sCurrentActivityThreadField.setAccessible(true);
-            return sCurrentActivityThreadField.get(null);
-        } catch (Exception e) {
-            Log.e("UtilsActivityLifecycle", "getActivityThreadInActivityThreadStaticField: " + e.getMessage());
-            return null;
-        }
-    }
-
-    private Object getActivityThreadInActivityThreadStaticMethod() {
-        try {
-            Class activityThreadClass = Class.forName("android.app.ActivityThread");
-            return activityThreadClass.getMethod("currentActivityThread").invoke(null);
-        } catch (Exception e) {
-            Log.e("UtilsActivityLifecycle", "getActivityThreadInActivityThreadStaticMethod: " + e.getMessage());
-            return null;
-        }
-    }
-
-    /**
-     * Set animators enabled.
-     */
-    private static void setAnimatorsEnabled() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && ValueAnimator.areAnimatorsEnabled()) {
-            return;
-        }
-        try {
-            //noinspection JavaReflectionMemberAccess
-            Field sDurationScaleField = ValueAnimator.class.getDeclaredField("sDurationScale");
-            sDurationScaleField.setAccessible(true);
-            //noinspection ConstantConditions
-            float sDurationScale = (Float) sDurationScaleField.get(null);
-            if (sDurationScale == 0f) {
-                sDurationScaleField.set(null, 1f);
-                Log.i("UtilsActivityLifecycle", "setAnimatorsEnabled: Animators are enabled now!");
-            }
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-}

app/src/main/java/com/test/easy/easycleanerjunk/utils/UtilsBridge.java

-package com.test.easy.easycleanerjunk.utils;
-
-import static android.Manifest.permission.CALL_PHONE;
-
-import android.app.Activity;
-import android.app.Application;
-import android.app.Notification;
-import android.content.Context;
-import android.content.Intent;
-import android.graphics.Bitmap;
-import android.graphics.drawable.Drawable;
-import android.net.Uri;
-import android.os.Build;
-import android.os.Parcelable;
-import android.text.TextUtils;
-import android.view.View;
-
-import androidx.annotation.LayoutRes;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.annotation.RequiresApi;
-import androidx.annotation.RequiresPermission;
-import androidx.annotation.StringRes;
-import androidx.core.app.NotificationCompat;
-
-import com.blankj.utilcode.util.ActivityUtils;
-import com.blankj.utilcode.util.AppUtils;
-import com.blankj.utilcode.util.BarUtils;
-import com.blankj.utilcode.util.ConvertUtils;
-import com.blankj.utilcode.util.DebouncingUtils;
-import com.blankj.utilcode.util.EncodeUtils;
-import com.blankj.utilcode.util.FileIOUtils;
-import com.blankj.utilcode.util.FileUtils;
-import com.blankj.utilcode.util.ImageUtils;
-import com.blankj.utilcode.util.IntentUtils;
-import com.blankj.utilcode.util.JsonUtils;
-import com.blankj.utilcode.util.KeyboardUtils;
-import com.blankj.utilcode.util.NotificationUtils;
-import com.blankj.utilcode.util.PermissionUtils;
-import com.blankj.utilcode.util.ProcessUtils;
-import com.blankj.utilcode.util.RomUtils;
-import com.blankj.utilcode.util.SDCardUtils;
-import com.blankj.utilcode.util.SPUtils;
-import com.blankj.utilcode.util.ScreenUtils;
-import com.blankj.utilcode.util.ServiceUtils;
-import com.blankj.utilcode.util.ShellUtils;
-import com.blankj.utilcode.util.SizeUtils;
-import com.blankj.utilcode.util.StringUtils;
-import com.blankj.utilcode.util.ThreadUtils;
-import com.blankj.utilcode.util.ThrowableUtils;
-import com.blankj.utilcode.util.ToastUtils;
-import com.blankj.utilcode.util.UriUtils;
-import com.blankj.utilcode.util.Utils;
-import com.blankj.utilcode.util.ViewUtils;
-
-import org.json.JSONArray;
-import org.json.JSONObject;
-
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.InputStream;
-import java.io.Serializable;
-import java.lang.reflect.Type;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * <pre>
- *     author: blankj
- *     blog  : http://blankj.com
- *     time  : 2020/03/19
- *     desc  :
- * </pre>
- */
-public class UtilsBridge {
-
-    static void init(Application app) {
-        UtilsActivityLifecycleImpl.INSTANCE.init(app);
-    }
-
-    static void unInit(Application app) {
-        UtilsActivityLifecycleImpl.INSTANCE.unInit(app);
-    }
-
-    static void preLoad() {
-       // preLoad(AdaptScreenUtils.getPreLoadRunnable());
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // UtilsActivityLifecycleImpl
-    ///////////////////////////////////////////////////////////////////////////
-    public static Activity getTopActivity() {
-        return UtilsActivityLifecycleImpl.INSTANCE.getTopActivity();
-    }
-
-    static void addOnAppStatusChangedListener(final Utils.OnAppStatusChangedListener listener) {
-        UtilsActivityLifecycleImpl.INSTANCE.addOnAppStatusChangedListener(listener);
-    }
-
-    static void removeOnAppStatusChangedListener(final Utils.OnAppStatusChangedListener listener) {
-        UtilsActivityLifecycleImpl.INSTANCE.removeOnAppStatusChangedListener(listener);
-    }
-
-    static void addActivityLifecycleCallbacks(final Utils.ActivityLifecycleCallbacks callbacks) {
-        UtilsActivityLifecycleImpl.INSTANCE.addActivityLifecycleCallbacks(callbacks);
-    }
-
-    static void removeActivityLifecycleCallbacks(final Utils.ActivityLifecycleCallbacks callbacks) {
-        UtilsActivityLifecycleImpl.INSTANCE.removeActivityLifecycleCallbacks(callbacks);
-    }
-
-    static void addActivityLifecycleCallbacks(final Activity activity,
-                                              final Utils.ActivityLifecycleCallbacks callbacks) {
-       UtilsActivityLifecycleImpl.INSTANCE.addActivityLifecycleCallbacks(activity, callbacks);
-    }
-
-    static void removeActivityLifecycleCallbacks(final Activity activity) {
-        UtilsActivityLifecycleImpl.INSTANCE.removeActivityLifecycleCallbacks(activity);
-    }
-
-    static void removeActivityLifecycleCallbacks(final Activity activity,
-                                                 final Utils.ActivityLifecycleCallbacks callbacks) {
-        UtilsActivityLifecycleImpl.INSTANCE.removeActivityLifecycleCallbacks(activity, callbacks);
-    }
-
-    static List<Activity> getActivityList() {
-        return UtilsActivityLifecycleImpl.INSTANCE.getActivityList();
-    }
-
-    static Application getApplicationByReflect() {
-        return UtilsActivityLifecycleImpl.INSTANCE.getApplicationByReflect();
-    }
-
-    static boolean isAppForeground() {
-        return UtilsActivityLifecycleImpl.INSTANCE.isAppForeground();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ActivityUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isActivityAlive(final Activity activity) {
-        return ActivityUtils.isActivityAlive(activity);
-    }
-
-    static String getLauncherActivity(final String pkg) {
-        return ActivityUtils.getLauncherActivity(pkg);
-    }
-
-    static Activity getActivityByContext(Context context) {
-        return ActivityUtils.getActivityByContext(context);
-    }
-
-    static void startHomeActivity() {
-        ActivityUtils.startHomeActivity();
-    }
-
-    static void finishAllActivities() {
-        ActivityUtils.finishAllActivities();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // AppUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isAppRunning(@NonNull final String pkgName) {
-        return AppUtils.isAppRunning(pkgName);
-    }
-
-    static boolean isAppInstalled(final String pkgName) {
-        return AppUtils.isAppInstalled(pkgName);
-    }
-
-    static boolean isAppDebug() {
-        return AppUtils.isAppDebug();
-    }
-
-    static void relaunchApp() {
-        AppUtils.relaunchApp();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // BarUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static int getStatusBarHeight() {
-        return com.blankj.utilcode.util.BarUtils.getStatusBarHeight();
-    }
-
-    static int getNavBarHeight() {
-        return BarUtils.getNavBarHeight();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ConvertUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static String bytes2HexString(final byte[] bytes) {
-        return ConvertUtils.bytes2HexString(bytes);
-    }
-
-    static byte[] hexString2Bytes(String hexString) {
-        return ConvertUtils.hexString2Bytes(hexString);
-    }
-
-    static byte[] string2Bytes(final String string) {
-        return ConvertUtils.string2Bytes(string);
-    }
-
-    static String bytes2String(final byte[] bytes) {
-        return ConvertUtils.bytes2String(bytes);
-    }
-
-    static byte[] jsonObject2Bytes(final JSONObject jsonObject) {
-        return ConvertUtils.jsonObject2Bytes(jsonObject);
-    }
-
-    static JSONObject bytes2JSONObject(final byte[] bytes) {
-        return ConvertUtils.bytes2JSONObject(bytes);
-    }
-
-    static byte[] jsonArray2Bytes(final JSONArray jsonArray) {
-        return ConvertUtils.jsonArray2Bytes(jsonArray);
-    }
-
-    static JSONArray bytes2JSONArray(final byte[] bytes) {
-        return ConvertUtils.bytes2JSONArray(bytes);
-    }
-
-    static byte[] parcelable2Bytes(final Parcelable parcelable) {
-        return ConvertUtils.parcelable2Bytes(parcelable);
-    }
-
-    static <T> T bytes2Parcelable(final byte[] bytes,
-                                  final Parcelable.Creator<T> creator) {
-        return ConvertUtils.bytes2Parcelable(bytes, creator);
-    }
-
-    static byte[] serializable2Bytes(final Serializable serializable) {
-        return ConvertUtils.serializable2Bytes(serializable);
-    }
-
-    static Object bytes2Object(final byte[] bytes) {
-        return ConvertUtils.bytes2Object(bytes);
-    }
-
-    static String byte2FitMemorySize(final long byteSize) {
-        return ConvertUtils.byte2FitMemorySize(byteSize);
-    }
-
-    static byte[] inputStream2Bytes(final InputStream is) {
-        return ConvertUtils.inputStream2Bytes(is);
-    }
-
-    static ByteArrayOutputStream input2OutputStream(final InputStream is) {
-        return ConvertUtils.input2OutputStream(is);
-    }
-
-    static List<String> inputStream2Lines(final InputStream is, final String charsetName) {
-        return ConvertUtils.inputStream2Lines(is, charsetName);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // DebouncingUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isValid(@NonNull final View view, final long duration) {
-        return DebouncingUtils.isValid(view, duration);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // EncodeUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static byte[] base64Encode(final byte[] input) {
-        return EncodeUtils.base64Encode(input);
-    }
-
-    static byte[] base64Decode(final byte[] input) {
-        return EncodeUtils.base64Decode(input);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // EncryptUtils
-    ///////////////////////////////////////////////////////////////////////////
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // FileIOUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean writeFileFromBytes(final File file,
-                                      final byte[] bytes) {
-        return FileIOUtils.writeFileFromBytesByChannel(file, bytes, true);
-    }
-
-    static byte[] readFile2Bytes(final File file) {
-        return FileIOUtils.readFile2BytesByChannel(file);
-    }
-
-    static boolean writeFileFromString(final String filePath, final String content, final boolean append) {
-        return FileIOUtils.writeFileFromString(filePath, content, append);
-    }
-
-    static boolean writeFileFromIS(final String filePath, final InputStream is) {
-        return FileIOUtils.writeFileFromIS(filePath, is);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // FileUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isFileExists(final File file) {
-        return FileUtils.isFileExists(file);
-    }
-
-    static File getFileByPath(final String filePath) {
-        return FileUtils.getFileByPath(filePath);
-    }
-
-    static boolean deleteAllInDir(final File dir) {
-        return FileUtils.deleteAllInDir(dir);
-    }
-
-    static boolean createOrExistsFile(final File file) {
-        return FileUtils.createOrExistsFile(file);
-    }
-
-    static boolean createOrExistsDir(final File file) {
-        return FileUtils.createOrExistsDir(file);
-    }
-
-    static boolean createFileByDeleteOldFile(final File file) {
-        return FileUtils.createFileByDeleteOldFile(file);
-    }
-
-    static long getFsTotalSize(String path) {
-        return FileUtils.getFsTotalSize(path);
-    }
-
-    static long getFsAvailableSize(String path) {
-        return FileUtils.getFsAvailableSize(path);
-    }
-
-    static void notifySystemToScan(File file) {
-        FileUtils.notifySystemToScan(file);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // GsonUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static String toJson(final Object object) {
-        return com.blankj.utilcode.util.GsonUtils.toJson(object);
-    }
-
-    static <T> T fromJson(final String json, final Type type) {
-        return com.blankj.utilcode.util.GsonUtils.fromJson(json, type);
-    }
-
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ImageUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static byte[] bitmap2Bytes(final Bitmap bitmap) {
-        return ImageUtils.bitmap2Bytes(bitmap);
-    }
-
-    static byte[] bitmap2Bytes(final Bitmap bitmap, final Bitmap.CompressFormat format, int quality) {
-        return ImageUtils.bitmap2Bytes(bitmap, format, quality);
-    }
-
-    static Bitmap bytes2Bitmap(final byte[] bytes) {
-        return ImageUtils.bytes2Bitmap(bytes);
-    }
-
-    static byte[] drawable2Bytes(final Drawable drawable) {
-        return ImageUtils.drawable2Bytes(drawable);
-    }
-
-    static byte[] drawable2Bytes(final Drawable drawable, final Bitmap.CompressFormat format, int quality) {
-        return ImageUtils.drawable2Bytes(drawable, format, quality);
-    }
-
-    static Drawable bytes2Drawable(final byte[] bytes) {
-        return ImageUtils.bytes2Drawable(bytes);
-    }
-
-    static Bitmap view2Bitmap(final View view) {
-        return ImageUtils.view2Bitmap(view);
-    }
-
-    static Bitmap drawable2Bitmap(final Drawable drawable) {
-        return ImageUtils.drawable2Bitmap(drawable);
-    }
-
-    static Drawable bitmap2Drawable(final Bitmap bitmap) {
-        return ImageUtils.bitmap2Drawable(bitmap);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // IntentUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isIntentAvailable(final Intent intent) {
-        return IntentUtils.isIntentAvailable(intent);
-    }
-
-    static Intent getLaunchAppIntent(final String pkgName) {
-        return IntentUtils.getLaunchAppIntent(pkgName);
-    }
-
-    static Intent getInstallAppIntent(final File file) {
-        return IntentUtils.getInstallAppIntent(file);
-    }
-
-    static Intent getInstallAppIntent(final Uri uri) {
-        return IntentUtils.getInstallAppIntent(uri);
-    }
-
-    static Intent getUninstallAppIntent(final String pkgName) {
-        return IntentUtils.getUninstallAppIntent(pkgName);
-    }
-
-    static Intent getDialIntent(final String phoneNumber) {
-        return IntentUtils.getDialIntent(phoneNumber);
-    }
-
-    @RequiresPermission(CALL_PHONE)
-    static Intent getCallIntent(final String phoneNumber) {
-        return IntentUtils.getCallIntent(phoneNumber);
-    }
-
-    static Intent getSendSmsIntent(final String phoneNumber, final String content) {
-        return IntentUtils.getSendSmsIntent(phoneNumber, content);
-    }
-
-    static Intent getLaunchAppDetailsSettingsIntent(final String pkgName, final boolean isNewTask) {
-        return IntentUtils.getLaunchAppDetailsSettingsIntent(pkgName, isNewTask);
-    }
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // JsonUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static String formatJson(String json) {
-        return JsonUtils.formatJson(json);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // KeyboardUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static void fixSoftInputLeaks(final Activity activity) {
-        KeyboardUtils.fixSoftInputLeaks(activity);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // NotificationUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static Notification getNotification(NotificationUtils.ChannelConfig channelConfig,
-                                        Utils.Consumer<NotificationCompat.Builder> consumer) {
-        return NotificationUtils.getNotification(channelConfig, consumer);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // PermissionUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isGranted(final String... permissions) {
-        return com.blankj.utilcode.util.PermissionUtils.isGranted(permissions);
-    }
-
-    @RequiresApi(api = Build.VERSION_CODES.M)
-    static boolean isGrantedDrawOverlays() {
-        return PermissionUtils.isGrantedDrawOverlays();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ProcessUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isMainProcess() {
-        return ProcessUtils.isMainProcess();
-    }
-
-    static String getForegroundProcessName() {
-        return ProcessUtils.getForegroundProcessName();
-    }
-
-    static String getCurrentProcessName() {
-        return ProcessUtils.getCurrentProcessName();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // RomUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isSamsung() {
-        return RomUtils.isSamsung();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ScreenUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static int getAppScreenWidth() {
-        return ScreenUtils.getAppScreenWidth();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // SDCardUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isSDCardEnableByEnvironment() {
-        return SDCardUtils.isSDCardEnableByEnvironment();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ServiceUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isServiceRunning(final String className) {
-        return ServiceUtils.isServiceRunning(className);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ShellUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static ShellUtils.CommandResult execCmd(final String command, final boolean isRooted) {
-        return ShellUtils.execCmd(command, isRooted);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // SizeUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static int dp2px(final float dpValue) {
-        return SizeUtils.dp2px(dpValue);
-    }
-
-    static int px2dp(final float pxValue) {
-        return SizeUtils.px2dp(pxValue);
-    }
-
-    static int sp2px(final float spValue) {
-        return SizeUtils.sp2px(spValue);
-    }
-
-    static int px2sp(final float pxValue) {
-        return SizeUtils.px2sp(pxValue);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // SpUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static com.blankj.utilcode.util.SPUtils getSpUtils4Utils() {
-        return SPUtils.getInstance("Utils");
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // StringUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static boolean isSpace(final String s) {
-        return StringUtils.isSpace(s);
-    }
-
-    static boolean equals(final CharSequence s1, final CharSequence s2) {
-        return StringUtils.equals(s1, s2);
-    }
-
-    static String getString(@StringRes int id) {
-        return StringUtils.getString(id);
-    }
-
-    static String getString(@StringRes int id, Object... formatArgs) {
-        return StringUtils.getString(id, formatArgs);
-    }
-
-    static String format(@Nullable String str, Object... args) {
-        return StringUtils.format(str, args);
-    }
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ThreadUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static <T> Utils.Task<T> doAsync(final Utils.Task<T> task) {
-        ThreadUtils.getCachedPool().execute(task);
-        return task;
-    }
-
-    static void runOnUiThread(final Runnable runnable) {
-        ThreadUtils.runOnUiThread(runnable);
-    }
-
-    static void runOnUiThreadDelayed(final Runnable runnable, long delayMillis) {
-        ThreadUtils.runOnUiThreadDelayed(runnable, delayMillis);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ThrowableUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static String getFullStackTrace(Throwable throwable) {
-        return ThrowableUtils.getFullStackTrace(throwable);
-    }
-
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ToastUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static void toastShowShort(final CharSequence text) {
-        ToastUtils.showShort(text);
-    }
-
-    static void toastCancel() {
-        ToastUtils.cancel();
-    }
-
-    private static void preLoad(final Runnable... runs) {
-        for (final Runnable r : runs) {
-            ThreadUtils.getCachedPool().execute(r);
-        }
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // UriUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static Uri file2Uri(final File file) {
-        return UriUtils.file2Uri(file);
-    }
-
-    static File uri2File(final Uri uri) {
-        return UriUtils.uri2File(uri);
-    }
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // ViewUtils
-    ///////////////////////////////////////////////////////////////////////////
-    static View layoutId2View(@LayoutRes final int layoutId) {
-        return ViewUtils.layoutId2View(layoutId);
-    }
-
-    static boolean isLayoutRtl() {
-        return ViewUtils.isLayoutRtl();
-    }
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Common
-    ///////////////////////////////////////////////////////////////////////////
-    static final class FileHead {
-
-        private String                        mName;
-        private LinkedHashMap<String, String> mFirst = new LinkedHashMap<>();
-        private LinkedHashMap<String, String> mLast  = new LinkedHashMap<>();
-
-        FileHead(String name) {
-            mName = name;
-        }
-
-        void addFirst(String key, String value) {
-            append2Host(mFirst, key, value);
-        }
-
-        void append(Map<String, String> extra) {
-            append2Host(mLast, extra);
-        }
-
-        void append(String key, String value) {
-            append2Host(mLast, key, value);
-        }
-
-        private void append2Host(Map<String, String> host, Map<String, String> extra) {
-            if (extra == null || extra.isEmpty()) {
-                return;
-            }
-            for (Map.Entry<String, String> entry : extra.entrySet()) {
-                append2Host(host, entry.getKey(), entry.getValue());
-            }
-        }
-
-        private void append2Host(Map<String, String> host, String key, String value) {
-            if (TextUtils.isEmpty(key) || TextUtils.isEmpty(value)) {
-                return;
-            }
-            int delta = 19 - key.length(); // 19 is length of "Device Manufacturer"
-            if (delta > 0) {
-                key = key + "                   ".substring(0, delta);
-            }
-            host.put(key, value);
-        }
-
-        public String getAppended() {
-            StringBuilder sb = new StringBuilder();
-            for (Map.Entry<String, String> entry : mLast.entrySet()) {
-                sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\n");
-            }
-            return sb.toString();
-        }
-
-        @Override
-        public String toString() {
-            StringBuilder sb = new StringBuilder();
-            String border = "************* " + mName + " Head ****************\n";
-            sb.append(border);
-            for (Map.Entry<String, String> entry : mFirst.entrySet()) {
-                sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\n");
-            }
-
-            sb.append("Rom Info           : ").append(RomUtils.getRomInfo()).append("\n");
-            sb.append("Device Manufacturer: ").append(Build.MANUFACTURER).append("\n");
-            sb.append("Device Model       : ").append(Build.MODEL).append("\n");
-            sb.append("Android Version    : ").append(Build.VERSION.RELEASE).append("\n");
-            sb.append("Android SDK        : ").append(Build.VERSION.SDK_INT).append("\n");
-            sb.append("App VersionName    : ").append(AppUtils.getAppVersionName()).append("\n");
-            sb.append("App VersionCode    : ").append(AppUtils.getAppVersionCode()).append("\n");
-
-            sb.append(getAppended());
-            return sb.append(border).append("\n").toString();
-        }
-    }
-}
\ No newline at end of file