修改广告，修改bug

app/build.gradle

@@ -123,5 +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.annotation.SuppressLint
 import android.app.Activity
 import android.app.Application
 import android.content.Intent
 import android.os.Bundle
 import android.text.TextUtils
+import android.util.Log
 import com.applovin.sdk.AppLovinMediationProvider
 import com.applovin.sdk.AppLovinSdk
 import com.applovin.sdk.AppLovinSdkInitializationConfiguration
 import com.google.android.gms.ads.MobileAds
-import com.google.android.gms.ads.identifier.AdvertisingIdClient
 import com.test.easy.easycleanerjunk.activity.splash.NewSplashActivity
 import com.test.easy.easycleanerjunk.fcm.ActionBroadcast
 import com.test.easy.easycleanerjunk.fcm.FCMUtil
@@ -20,9 +19,8 @@ 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 java.util.Collections
+import com.test.easy.easycleanerjunk.utils.UtilsBridge
 import java.util.UUID
 import java.util.concurrent.Executors
 
@@ -59,12 +57,12 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
                     val initConfigBuilder = AppLovinSdkInitializationConfiguration.builder(
                         "GGPreND6SRmCt1zJgn5faiLGD8c2PVGPLgPpSg7cHanVTud1DhtuI9MmteTqlEviaJ57WnxW68kQDaATJ5z3cW",
                         context
-                    ).setMediationProvider(AppLovinMediationProvider.ADMOB)
-                    val currentGaid = AdvertisingIdClient.getAdvertisingIdInfo(context).id
-                    if (currentGaid != null) {
-                        initConfigBuilder.testDeviceAdvertisingIds =
-                            Collections.singletonList(currentGaid)
-                    }
+                    ).setMediationProvider(AppLovinMediationProvider.MAX)
+//                    val currentGaid = AdvertisingIdClient.getAdvertisingIdInfo(context).id
+//                    if (currentGaid != null) {
+//                        initConfigBuilder.testDeviceAdvertisingIds =
+//                            Collections.singletonList(currentGaid)
+//                    }
                     val initConfig = initConfigBuilder.build()
                     // Initialize the SDK with the configuration
                     AppLovinSdk.getInstance(context).initialize(initConfig) {
@@ -93,15 +91,17 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
     }
 
     private var count = 0
-    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+        Log.e("MXL", "onActivityCreated: "+activity.localClassName )
+    }
 
     override fun onActivityStarted(activity: Activity) {
         count++
         lastTimeResume = System.currentTimeMillis()
         if (count == 1 && isHotLaunch()) {
 
-            val topActivity: Activity? = ActivityManagerUtils.getInstance().topActivity
-
+            //val topActivity: Activity? = ActivityManagerUtils.getInstance().topActivity
+            val topActivity= UtilsBridge.getTopActivity()
             var flag = if (topActivity == null) {
                 true
             } else {

app/src/main/java/com/test/easy/easycleanerjunk/activity/splash/NewSplashActivity.kt

@@ -22,7 +22,6 @@ import com.test.easy.easycleanerjunk.utils.BarUtils
 @SuppressLint("CustomSplashScreen")
 class NewSplashActivity : BaseActivity<ActivityLayoutSplashBinding>(),
     PrivacyAgreementManager.onUserPrivacyAggreementListener, ProgressManager.ProgressListener {
-    private val TAG = "NewSplashActivity"
     private fun initStatusBar() {
         BarUtils.setStatusBarLightMode(this, true)
         BarUtils.setStatusBarColor(this, Color.TRANSPARENT)

app/src/main/java/com/test/easy/easycleanerjunk/activity/splash/ProgressManager.kt

@@ -3,7 +3,9 @@ package com.test.easy.easycleanerjunk.activity.splash
 import android.os.Handler
 import androidx.core.view.isVisible
 import com.test.easy.easycleanerjunk.databinding.ActivityLayoutSplashBinding
+import com.test.easy.easycleanerjunk.helps.EventUtils
 import com.test.easy.easycleanerjunk.utils.SPUtils
+import org.json.JSONObject
 
 class ProgressManager {
 
@@ -42,11 +44,15 @@ class ProgressManager {
                 if (!mIsPaused) {
                     mProgress++ // 计算进度
                     binding.pb.progress = mProgress
-                    if (mProgress < 9) {
+                    if (mProgress < loadTime) {
                         mHandler.postDelayed(this, 1000) // 每秒钟更新一次进度
                     } else {
                         listener.onProgressMax()
                         pauseProgress()
+                        val obj = JSONObject()
+                        obj.put("reason", "timeout")
+                        obj.put("ad_unit", "openAd")
+                        EventUtils.event("ad_show_error", ext = obj)
                     }
                 }
             }

app/src/main/java/com/test/easy/easycleanerjunk/helps/ConfigHelper.kt

@@ -35,6 +35,7 @@ object ConfigHelper {
     val noLoadingActivities = listOf(
         "full", // 过滤全屏广告
         "adActivity",
+        "AdActivity",
         "AppLovinFullscreenActivity",
         NewSplashActivity::class.java.simpleName
         // 返回前台时不跳转启动页的 activity

app/src/main/java/com/test/easy/easycleanerjunk/helps/ads/MaxAdUtils.kt

@@ -84,7 +84,7 @@ object MaxAdUtils {
                     mOpenAd=null
                     onLoad?.invoke()
                     maxAdPullReport(null, "AppOpenAd", p1.message)
-                    Log.e("MXL", "onAdLoadFailed: " + p1)
+                   // Log.e("MXL", "onAdLoadFailed: " + p1)
                     AdDisplayUtils.getInstance().incrementAdRequestFailCount()
                 }
 
@@ -159,10 +159,10 @@ object MaxAdUtils {
         } else {
             onHidden?.invoke()
             mOpenAd?.loadAd()
-            val obj = JSONObject()
-            obj.put("reason", "no_ad")
-            obj.put("ad_unit", "openAd")
-            EventUtils.event("ad_show_error", ext = obj)
+//            val obj = JSONObject()
+//            obj.put("reason", "no_ad")
+//            obj.put("ad_unit", "openAd")
+//            EventUtils.event("ad_show_error", ext = obj)
         }
     }
 
@@ -223,6 +223,7 @@ object MaxAdUtils {
                 maxAdPullReport(null, "InterstitialAd", p1.message)
                 onLoad?.invoke()
                 AdDisplayUtils.getInstance().incrementAdRequestFailCount()
+                Log.e("MXL", "onAdLoadFailed: "+p1.message )
 //                retryAttempt++
 //                Handler(Looper.getMainLooper()).postDelayed({
 //                    retryAttempt++

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