Skip to content

E
Easy Cleaner Junk
Commit 4962e7ec authored by maxiaoliang's avatar maxiaoliang
Browse files
Options

修改问题

parent bf26c896
Show whitespace changes
Inline Side-by-side
Showing with 156 additions and 1225 deletions
app/build.gradle
View file @ 4962e7ec
...@@ -123,6 +123,6 @@ dependencies { ...@@ -123,6 +123,6 @@ dependencies {
implementation 'com.applovin.mediation:facebook-adapter:+' implementation 'com.applovin.mediation:facebook-adapter:+'
implementation 'com.applovin.mediation:mintegral-adapter:+' implementation 'com.applovin.mediation:mintegral-adapter:+'
implementation 'com.applovin.mediation:bytedance-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
View file @ 4962e7ec
package com.test.easy.easycleanerjunk package com.test.easy.easycleanerjunk
import android.app.Activity import android.app.Activity
import android.app.Application
import android.content.Intent import android.content.Intent
import android.os.Bundle import android.os.Bundle
import android.text.TextUtils import android.text.TextUtils
...@@ -19,13 +18,13 @@ import com.test.easy.easycleanerjunk.helps.ConfigHelper ...@@ -19,13 +18,13 @@ import com.test.easy.easycleanerjunk.helps.ConfigHelper
import com.test.easy.easycleanerjunk.helps.InstallHelps import com.test.easy.easycleanerjunk.helps.InstallHelps
import com.test.easy.easycleanerjunk.helps.ads.AdmobUtils import com.test.easy.easycleanerjunk.helps.ads.AdmobUtils
import com.test.easy.easycleanerjunk.helps.ads.MaxAdUtils 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.SPUtils
import com.test.easy.easycleanerjunk.utils.UtilsBridge
import java.util.UUID import java.util.UUID
import java.util.concurrent.Executors import java.util.concurrent.Executors
class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks { class MyApplication : BaseApplication() {
companion object { companion object {
@JvmField @JvmField
...@@ -34,9 +33,10 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks ...@@ -34,9 +33,10 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
var uuid = "" var uuid = ""
override fun init() { override fun init() {
registerActivityLifecycleCallbacks(this) // registerActivityLifecycleCallbacks(this)
initUUid() initUUid()
initApp() initApp()
} }
private fun initUUid() { private fun initUUid() {
...@@ -75,9 +75,8 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks ...@@ -75,9 +75,8 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
} }
BlackUtils.requestBlack() BlackUtils.requestBlack()
if (ConfigHelper.ifAgreePrivacy) { if (ConfigHelper.ifAgreePrivacy) {
} }
initLifeListener()
} }
private fun initNotificationWork() { private fun initNotificationWork() {
...@@ -89,10 +88,19 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks ...@@ -89,10 +88,19 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
ActionBroadcast.initBroadcast(this) ActionBroadcast.initBroadcast(this)
} }
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 private var count = 0
override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) { override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
Log.e("MXL", "onActivityCreated: "+activity.localClassName ) ActivityManagerUtils.getInstance().addActivity(activity)
} }
override fun onActivityStarted(activity: Activity) { override fun onActivityStarted(activity: Activity) {
...@@ -100,8 +108,8 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks ...@@ -100,8 +108,8 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
lastTimeResume = System.currentTimeMillis() lastTimeResume = System.currentTimeMillis()
if (count == 1 && isHotLaunch()) { 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) { var flag = if (topActivity == null) {
true true
} else { } else {
...@@ -112,7 +120,7 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks ...@@ -112,7 +120,7 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
flag = false flag = false
} }
if (flag) { if (flag) {
if (ConfigHelper.admobTrueMaxFlase == 0) { if(ConfigHelper.admobTrueMaxFlase==0){
if (MaxAdUtils.isOpenAdLoaded()) { if (MaxAdUtils.isOpenAdLoaded()) {
MaxAdUtils.showAppOpenAd(activity) MaxAdUtils.showAppOpenAd(activity)
} else { } else {
...@@ -125,7 +133,7 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks ...@@ -125,7 +133,7 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
putExtra("type", -1) putExtra("type", -1)
}) })
} }
} else { }else{
if (AdmobUtils.isOpenAdLoaded()) { if (AdmobUtils.isOpenAdLoaded()) {
AdmobUtils.showAppOpenAd(activity) AdmobUtils.showAppOpenAd(activity)
} else { } else {
...@@ -152,6 +160,7 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks ...@@ -152,6 +160,7 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
override fun onActivityPaused(activity: Activity) { override fun onActivityPaused(activity: Activity) {
PAUSED_VALUE = 2 PAUSED_VALUE = 2
lastTimePause = System.currentTimeMillis() lastTimePause = System.currentTimeMillis()
Log.d("glc", "PAUSED_VALUE:" + PAUSED_VALUE)
} }
...@@ -162,13 +171,87 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks ...@@ -162,13 +171,87 @@ class MyApplication : BaseApplication(), Application.ActivityLifecycleCallbacks
override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {} override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
override fun onActivityDestroyed(activity: Activity) {} 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
} }
// 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 deleted 100644 → 0
View file @ bf26c896
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 deleted 100644 → 0
View file @ bf26c896
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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment