midi-android/moduleUtil/src/main/java/com/xscm/moduleutil/base/CommonAppContext.java

package com.xscm.moduleutil.base;

import android.app.Activity;
import android.app.ActivityManager;
import android.app.Application;
import android.content.ComponentCallbacks2;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.Signature;
import android.content.res.Configuration;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.PowerManager;
import android.provider.Settings;
import android.util.Base64;
import android.util.DisplayMetrics;
import android.webkit.WebView;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.multidex.MultiDex;
import androidx.multidex.MultiDexApplication;

import com.alibaba.android.arouter.launcher.ARouter;
import com.blankj.utilcode.util.AppUtils;
import com.blankj.utilcode.util.FileUtils;
import com.blankj.utilcode.util.LogUtils;
import com.blankj.utilcode.util.ProcessUtils;
import com.lahm.library.EasyProtectorLib;
import com.lahm.library.EmulatorCheckCallback;
import com.tencent.imsdk.v2.V2TIMAdvancedMsgListener;
import com.tencent.imsdk.v2.V2TIMManager;
import com.tencent.imsdk.v2.V2TIMMessage;
import com.tencent.imsdk.v2.V2TIMMessageManager;
import com.tencent.imsdk.v2.V2TIMMessageReceipt;
import com.tencent.imsdk.v2.V2TIMValueCallback;
import com.xscm.moduleutil.bean.UserBean;
import com.xscm.moduleutil.bean.UserInfo;
import com.xscm.moduleutil.event.AppLifecycleEvent;
import com.xscm.moduleutil.event.UnreadCountEvent;
import com.xscm.moduleutil.http.RetrofitClient;
import com.xscm.moduleutil.interfaces.AppLifecycleUtil;
import com.xscm.moduleutil.listener.MessageListenerSingleton;
import com.xscm.moduleutil.rtc.AgoraManager;
import com.xscm.moduleutil.service.MqttConnect;
import com.xscm.moduleutil.utils.ARouteConstants;
import com.xscm.moduleutil.utils.CrashHandler;
import com.xscm.moduleutil.utils.SpUtil;
import com.xscm.moduleutil.utils.UtilConfig;
import com.xscm.moduleutil.utils.config.EnvironmentEnum;
import com.xscm.moduleutil.utils.config.EnvironmentPrefs;
import com.xscm.moduleutil.widget.CommonAppConfig;
import com.scwang.smartrefresh.layout.SmartRefreshLayout;
import com.scwang.smartrefresh.layout.api.DefaultRefreshFooterCreator;
import com.scwang.smartrefresh.layout.api.DefaultRefreshHeaderCreator;
import com.scwang.smartrefresh.layout.api.RefreshFooter;
import com.scwang.smartrefresh.layout.api.RefreshHeader;
import com.scwang.smartrefresh.layout.api.RefreshLayout;
import com.scwang.smartrefresh.layout.footer.ClassicsFooter;
import com.scwang.smartrefresh.layout.header.ClassicsHeader;
import com.tencent.bugly.crashreport.CrashReport;
import com.tencent.qcloud.tuicore.TUILogin;
import com.tencent.qcloud.tuicore.interfaces.TUICallback;

import org.eclipse.paho.client.mqttv3.MqttClient;
import org.greenrobot.eventbus.EventBus;

import java.lang.reflect.Method;
import java.security.MessageDigest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import lombok.Getter;
import lombok.Setter;


/**
 * Created by cxf on 2017/8/3.
 */

public class CommonAppContext extends MultiDexApplication  implements Application.ActivityLifecycleCallbacks {

    private static CommonAppContext sInstance;
    private static Handler sMainThreadHandler;
    private int mCount;
    private boolean mFront;//是否前台
    public String emulator = "0";
    @Getter
    private EnvironmentEnum currentEnvironment;
    public UserBean mUserBean;

    public boolean isShow;
    public boolean isPlaying;

    public String playId;
    public String lable_id;
    public boolean isMicPlace;

    public boolean isShowAg;

    public boolean isRoomJoininj=false;

    public String playCover;
    public boolean showSelf;//盲盒是否能送自己
    public String playName;
    private MqttConnect mqttConnect=null;

    // 添加后台状态标记
    private boolean wasInBackground = false;

    public boolean isMai=false;

    public void onAppBackground() {
        wasInBackground = true;
    }

    public void onAppForeground() {
        wasInBackground = false;
    }

    public boolean wasInBackground() {
        return wasInBackground;
    }

    private int activityCount = 0;

    private AppStateListener appStateListener;
    private boolean isListeningUnreadCount = false;
    public boolean onConnectFailed=false;//是否重连

    public Map<String, Integer> onlineMap=new HashMap<>();

    public void setOnlineMap(Map<String, Integer> onlineMap) {
        this.onlineMap = onlineMap;
    }

    public Map<String, Integer> getOnlineMap() {
        return onlineMap;
    }

    @Setter
    @Getter
    public UnreadCountEvent unreadCountEvent;

    @Override
    public void onCreate() {
        super.onCreate();
        sInstance = this;
        sMainThreadHandler = new Handler();
        EnvironmentPrefs prefs = new EnvironmentPrefs(this);
        // 添加内存优化配置
        optimizeMemorySettings();
        currentEnvironment = prefs.getSelectedEnvironment();
        initialization();
        registerActivityLifecycleCallbacks(this);
        appStateListener = AppStateManager.getInstance();
        startListeningUnreadMessageCount();
        // 全局设置字体不缩放
        adjustFontScale(getResources().getConfiguration());
        CrashHandler.init(this);


    }

    public void adjustFontScale(Configuration configuration) {
        if (configuration.fontScale != 1.0f) {
            configuration.fontScale = 1.0f;
            DisplayMetrics metrics = getResources().getDisplayMetrics();
            getResources().updateConfiguration(configuration, metrics);
        }
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        // 配置变化时重新应用字体设置
        adjustFontScale(newConfig);
    }

    // 在适当的位置（如onCreate或onResume）添加实时监听
    protected void startListeningUnreadMessageCount() {
        if (!isListeningUnreadCount) {
            // 添加未读消息数变化监听器
            V2TIMMessageManager messageManager = V2TIMManager.getMessageManager();
            messageManager.addAdvancedMsgListener(new V2TIMAdvancedMsgListener() {
                @Override
                public void onRecvNewMessage(V2TIMMessage msg) {
                    // 收到新消息时更新未读数
                    updateUnreadMessageCount();
                }

                @Override
                public void onRecvC2CReadReceipt(List<V2TIMMessageReceipt> receiptList) {
                    // 收到C2C消息已读回执时更新未读数
                    updateUnreadMessageCount();
                }

            });


            isListeningUnreadCount = true;
            // 首次获取未读数
            updateUnreadMessageCount();
        }
    }

    // 更新未读消息数的方法
    private void updateUnreadMessageCount() {
        V2TIMManager.getConversationManager().getTotalUnreadMessageCount(new V2TIMValueCallback<Long>() {
            @Override
            public void onSuccess(Long aLong) {
                // 通知未读数变化
                notifyUnreadCountChanged(aLong != null ? aLong : 0L);
            }

            @Override
            public void onError(int code, String desc) {
                // 错误处理
                notifyUnreadCountChanged(0L);
            }
        });
    }

    // 通知未读数变化的方法（可以发送广播或EventBus事件）
    private void notifyUnreadCountChanged(long unreadCount) {
        UnreadCountEvent event =unreadCountEvent;
        if (event==null){
            event=new UnreadCountEvent();
        }
        event.setALong(unreadCount);
        // 使用EventBus通知
        CommonAppContext.getInstance().setUnreadCountEvent(event);
         EventBus.getDefault().post(event);
    }
    /**
     * 检查网络是否可用
     * @return true表示网络可用，false表示网络不可用
     */
    public boolean isNetworkAvailable() {
        try {
            // 获取网络连接管理器
            android.net.ConnectivityManager connectivityManager =
                    (android.net.ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

            if (connectivityManager != null) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                    // Android 6.0及以上版本
                    android.net.Network network = connectivityManager.getActiveNetwork();
                    if (network != null) {
                        android.net.NetworkCapabilities capabilities =
                                connectivityManager.getNetworkCapabilities(network);
                        if (capabilities != null) {
                            // 检查是否有网络连接并且可以访问互联网
                            return capabilities.hasCapability(android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
                                    capabilities.hasCapability(android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED);
                        }
                    }
                } else {
                    // Android 6.0以下版本
                    android.net.NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
                    return activeNetworkInfo != null && activeNetworkInfo.isConnected();
                }
            }
        } catch (Exception e) {
            LogUtils.e("Network availability check failed: " + e.getMessage());
        }

        return false;
    }

    /**
     * 检查网络是否可用（简化版本）
     * @return true表示网络可用，false表示网络不可用
     */
    public boolean isNetworkConnected() {
        try {
            android.net.ConnectivityManager connectivityManager =
                    (android.net.ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

            if (connectivityManager != null) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                    android.net.Network network = connectivityManager.getActiveNetwork();
                    return network != null;
                } else {
                    android.net.NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
                    return activeNetworkInfo != null && activeNetworkInfo.isConnected();
                }
            }
        } catch (Exception e) {
            LogUtils.e("Network connection check failed: " + e.getMessage());
        }

        return false;
    }

    /**
     * 优化内存设置
     */
    private void optimizeMemorySettings() {
        try {
            // 请求降低内存负载
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                // 启用自动内存管理优化
                registerComponentCallbacks(new ComponentCallbacks2() {
                    @Override
                    public void onTrimMemory(int level) {
                        handleMemoryTrim(level);
                    }

                    @Override
                    public void onConfigurationChanged(@NonNull Configuration newConfig) {}

                    @Override
                    public void onLowMemory() {
                        // 内存极低时的处理
                        releaseNonEssentialResources();
                    }
                });
            }
        } catch (Exception e) {
            LogUtils.e("Memory optimization setup failed: " + e.getMessage());
        }
    }

    /**
     * 处理内存削减事件
     * @param level 削减级别
     */
    private void handleMemoryTrim(int level) {
        switch (level) {
            case TRIM_MEMORY_RUNNING_MODERATE:
                // 应用正在运行，内存开始紧张
                LogUtils.d("Memory trim: moderate");
                break;
            case TRIM_MEMORY_RUNNING_LOW:
                // 应用正在运行，内存更加紧张
                LogUtils.d("Memory trim: low");
                releaseNonEssentialResources();
                break;
            case TRIM_MEMORY_RUNNING_CRITICAL:
                // 应用仍在运行，但系统已开始杀死后台进程
                LogUtils.d("Memory trim: critical");
                releaseAllNonEssentialResources();
                break;
            case TRIM_MEMORY_UI_HIDDEN:
                // 应用UI已隐藏，可以释放UI相关资源
                LogUtils.d("Memory trim: UI hidden");
                releaseUIResources();
                break;
            case TRIM_MEMORY_BACKGROUND:
                // 应用处于LRU列表中较远位置
                LogUtils.d("Memory trim: background");
                break;
            case TRIM_MEMORY_MODERATE:
                // 应用处于LRU列表中间位置
                LogUtils.d("Memory trim: moderate background");
                releaseAllNonEssentialResources();
                break;
            case TRIM_MEMORY_COMPLETE:
                // 应用处于LRU列表中最远位置，即将被杀死
                LogUtils.d("Memory trim: complete");
                releaseAllResources();
                break;
        }
    }
    /**
     * 释放非必要资源
     */
    private void releaseNonEssentialResources() {
        try {
            // 清理图片缓存
            // Glide.get(this).clearMemory();

            // 释放MQTT资源
            if (mqttConnect != null) {
                mqttConnect.close();
            }

            // 通知各个组件释放资源
            // EventBus.getDefault().post(new MemoryTrimEvent());
        } catch (Exception e) {
            LogUtils.e("Error releasing non-essential resources: " + e.getMessage());
        }
    }

    /**
     * 释放所有非必要资源
     */
    private void releaseAllNonEssentialResources() {
        try {
            releaseNonEssentialResources();

            // 进行垃圾回收
            System.gc();
            System.runFinalization();
        } catch (Exception e) {
            LogUtils.e("Error releasing all non-essential resources: " + e.getMessage());
        }
    }

    /**
     * 释放UI相关资源
     */
    private void releaseUIResources() {
        try {
            // 可以在这里通知UI组件释放资源
        } catch (Exception e) {
            LogUtils.e("Error releasing UI resources: " + e.getMessage());
        }
    }

    /**
     * 释放所有资源
     */
    private void releaseAllResources() {
        try {
            releaseAllNonEssentialResources();
            releaseUIResources();
        } catch (Exception e) {
            LogUtils.e("Error releasing all resources: " + e.getMessage());
        }
    }

    public void setAppStateListener(AppStateListener listener) {
        this.appStateListener = listener;
    }
    public void initialization(){
        UtilConfig.init(this);
//        registerActivityLifecycleCallbacks();
        initWebView();
        if (ProcessUtils.isMainProcess()) {
            initARouter();
            if (SpUtil.isAgreePolicy()) {
                checkInEmulator();
                UtilConfig.checkInEmulator();
                AgoraManager.getInstance(this);
                AgoraManager.init(currentEnvironment.getSwSdkAppId());
                MessageListenerSingleton.getInstance();
                CrashReport.initCrashReport(this, "ac3ed4d89f", true);/*bugly初始化*/
//                // 启动 MQTT 服务
//                Intent mqttServiceIntent = new Intent(this, MyMqttService.class);
//                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
//                    startForegroundService(mqttServiceIntent);
//                } else {
//                    startService(mqttServiceIntent);
//                }

//                mqttConnect=MqttConnect.getInstance(this,"tcp://1.13.181.248","android-"+ MqttClient.generateClientId());
                mqttConnect=MqttConnect.getInstance(this,"tcp://62.234.12.147","android-"+ MqttClient.generateClientId());
                mqttConnect.mqttClient();

                // 每次启动应用时重置状态
                SpUtil.getInstance().setBooleanValue("youth_model_shown", false);
                startInitSdk();
                
                // 启动IM连接服务
//                IMServiceManager.getInstance().startIMService(this);
            }
        }
//        piaoPingManager = PiaoPingManager.getInstance(this);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (!Settings.canDrawOverlays(this)) {
                Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, Uri.parse("package:" + getPackageName()));
                startActivityForResult(intent, 100);
            }
        }

//        requestBatteryOptimizationExemption();
    }
    private void requestBatteryOptimizationExemption() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            Intent intent = new Intent();
            String packageName = getPackageName();
            PowerManager pm = (PowerManager) getSystemService(POWER_SERVICE);
            if (pm != null && !pm.isIgnoringBatteryOptimizations(packageName)) {
                intent.setAction(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
                intent.setData(Uri.parse("package:" + packageName));
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                try {
                    startActivity(intent);
                } catch (Exception e) {
                    LogUtils.e("Failed to request battery optimization exemption: " + e.getMessage());
                }
            }
        }
    }
    private void startActivityForResult(Intent intent, int i) {
    }


//    private PiaoPingManager piaoPingManager;

    private void initARouter() {
        if (true) {
            ARouter.openDebug();
            ARouter.openLog();
        }
        ARouter.init(this);

    }

    private void initWebView() {
        //Android P 以及之后版本不支持同时从多个进程使用具有相同数据目录的WebView
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            String processName = getProcessName(this);
            if (!AppUtils.getAppPackageName().equals(processName)) {//判断不等于默认进程名称
                WebView.setDataDirectorySuffix(processName);
            }
        }
    }

    public String getProcessName(Context context) {
        if (context == null) return null;
        ActivityManager manager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        for (ActivityManager.RunningAppProcessInfo processInfo : manager.getRunningAppProcesses()) {
            if (processInfo.pid == android.os.Process.myPid()) {
                return processInfo.processName;
            }
        }
        return null;
    }

    @Override
    protected void attachBaseContext(Context base) {
        MultiDex.install(this);
        super.attachBaseContext(base);
    }

    public static CommonAppContext getInstance() {
        if (sInstance == null) {
            try {
                Class clazz = Class.forName("android.app.ActivityThread");
                Method method = clazz.getMethod("currentApplication", new Class[]{});
                Object obj = method.invoke(null, new Object[]{});
                if (obj != null && obj instanceof CommonAppContext) {
                    sInstance = (CommonAppContext) obj;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return sInstance;
    }

    public void checkInEmulator() {
        emulator = EasyProtectorLib.checkIsRunningInEmulator(this, new EmulatorCheckCallback() {
            @Override
            public void findEmulator(String emulatorInfo) {
//                Logger.e(emulatorInfo);
            }
        }) ? "1" : "0";
    }

    public static void postDelayed(Runnable runnable, long delayMillis) {
        if (sMainThreadHandler != null) {
            sMainThreadHandler.postDelayed(runnable, delayMillis);
        }
    }

    public static void post(Runnable runnable) {
        if (sMainThreadHandler != null) {
            sMainThreadHandler.post(runnable);
        }
    }

    public String getToken() {
        return SpUtil.getToken();
    }

    private void registerActivityLifecycleCallbacks() {
        registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {

            }

            @Override
            public void onActivityStarted(Activity activity) {
                mCount++;
                if (!mFront) {
                    mFront = true;
                    LogUtils.e("AppContext------->处于前台");
                    EventBus.getDefault().post(new AppLifecycleEvent(true));
                    CommonAppConfig.getInstance().setFrontGround(true);
//                    FloatWindowHelper.setFloatWindowVisible(true);
                    AppLifecycleUtil.onAppFrontGround();
                    // 确保在主线程中订阅
                    if (activity != null && !activity.isFinishing()) {
                        activity.runOnUiThread(() -> {
//                            if (piaoPingManager != null) {
//                                piaoPingManager.subscribe();
//                            }
                        });
                    }
                }
            }

            @Override
            public void onActivityResumed(Activity activity) {

            }

            @Override
            public void onActivityPaused(Activity activity) {

            }

            @Override
            public void onActivityStopped(Activity activity) {
                mCount--;
                if (mCount == 0) {
                    mFront = false;
                    LogUtils.e("AppContext------->处于后台");
                    EventBus.getDefault().post(new AppLifecycleEvent(false));
                    CommonAppConfig.getInstance().setFrontGround(false);
//                    FloatWindowHelper.setFloatWindowVisible(false);
                    AppLifecycleUtil.onAppBackGround();
                    if (activity != null && !activity.isFinishing()) {
                        activity.runOnUiThread(() -> {
//                            if (piaoPingManager != null) {
//                                piaoPingManager.unsubscribe();
//                            }
                        });
                    }
                }
            }

            @Override
            public void onActivitySaveInstanceState(Activity activity, Bundle outState) {

            }

            @Override
            public void onActivityDestroyed(Activity activity) {

            }
        });
    }

    /**
     * 获取App签名md5值
     */
    public String getAppSignature() {
        try {
            PackageInfo info =
                    this.getPackageManager().getPackageInfo(this.getPackageName(),
                            PackageManager.GET_SIGNATURES);
            if (info != null) {
                Signature[] signs = info.signatures;
                byte[] bytes = signs[0].toByteArray();
                MessageDigest md = MessageDigest.getInstance("MD5");
                md.update(bytes);
                bytes = md.digest();
                StringBuilder stringBuilder = new StringBuilder(2 * bytes.length);
                for (int i = 0; ; i++) {
                    if (i >= bytes.length) {
                        return stringBuilder.toString();
                    }
                    String str = Integer.toString(0xFF & bytes[i], 16);
                    if (str.length() == 1) {
                        str = "0" + str;
                    }
                    stringBuilder.append(str);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取facebook散列秘钥
     */
    public String getFacebookHashKey() {
        try {
            PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_SIGNATURES);
            for (Signature signature : info.signatures) {
                MessageDigest md = MessageDigest.getInstance("SHA");
                md.update(signature.toByteArray());
                return Base64.encodeToString(md.digest(), Base64.DEFAULT);
            }
        } catch (Exception e) {
            return "get error";
        }
        return null;
    }

    public boolean isFront() {
        return mFront;
    }

    public void startInitSdk() {
        UserBean userBean = SpUtil.getUserBean();
        if (userBean != null) {
            // 在用户 UI 点击登录的时候调用
            TUILogin.login(getBaseContext(), CommonAppContext.getInstance().getCurrentEnvironment().getSdkAppId(), "u" + userBean.getUser_id(), userBean.getTencent_im(), new TUICallback() {
                @Override
                public void onError(final int code, final String desc) {
                    LogUtils.e("@@@1", code, "描述：", desc);
                }

                @Override
                public void onSuccess() {
                    LogUtils.e("@@@", "成功");

                }
            });
        }
    }

    public void setUser(UserBean userBean) {
        mUserBean = userBean;
        SpUtil.saveUserId(userBean.getUser_id());
        SpUtil.saveUserBean(userBean);
        SpUtil.putToken(userBean.getToken());
    }

    public UserBean getUser() {
        if (mUserBean == null) {
            mUserBean = SpUtil.getUserBean();
        }
        return mUserBean;
    }

    public UserInfo getUserInfo() {
        UserInfo userInfo = SpUtil.getUserInfo();
        return userInfo;
    }

    public void setUserBean(UserBean bean) {
        mUserBean = bean;
    }

    public void clearLoginInfo() throws ClassNotFoundException {
//        mUid = null;
//        mToken = null;
//        SpUtil.getInstance().removeValue(
//                SPConstants.USER_ID, SPConstants.TOKEN, SPConstants.USER_INFO
//        );
        isShow = false;
        isPlaying = false;
        mUserBean = null;
        SpUtil.saveUserId(-1);
        SpUtil.saveUserBean(new UserBean());
        SpUtil.putToken("");

//        piaoPingManager.unsubscribe();
        FileUtils.deleteAllInDir(getCacheDir());
        FileUtils.deleteAllInDir(getExternalCacheDir());
        AgoraManager.getInstance(getApplicationContext()).destroy();
        // 每次启动应用时重置状态
        SpUtil.setBooleanValue("youth_model_shown", false);

        // 发送广播通知所有Activity刷新状态
        Intent refreshIntent = new Intent("com.xscm.moduleutil.ACTION_USER_LOGOUT");
        sendBroadcast(refreshIntent);
        Intent intent = new Intent("com.xscm.action.LAUNCH_PAGE");
        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
        getApplicationContext().startActivity(intent);
    }

    public static boolean isAlipayInstalled(Context context) {
        try {
            context.getPackageManager().getPackageInfo("com.eg.android.AlipayGphone", 0);
            return true;//安装了支付宝
        } catch (PackageManager.NameNotFoundException e) {
            return false; //未安装支付宝
        }
    }

    //static 代码段可以防止内存泄露
    static {
        //设置全局的Header构建器
        SmartRefreshLayout.setDefaultRefreshHeaderCreator(new DefaultRefreshHeaderCreator() {
            @Override
            public RefreshHeader createRefreshHeader(Context context, RefreshLayout layout) {
                ClassicsHeader header = new ClassicsHeader(context);
                header.setDrawableSize(20);
                header.setFinishDuration(0);
                return header;//.setTimeFormat(new DynamicTimeFormat("更新于 %s"));//指定为经典Header，默认是 贝塞尔雷达Header
//                return new CustomRefreshHeader(context);//.setTimeFormat(new DynamicTimeFormat("更新于 %s"));//指定为经典Header，默认是 贝塞尔雷达Header
            }
        });
        //设置全局的Footer构建器
        SmartRefreshLayout.setDefaultRefreshFooterCreator(new DefaultRefreshFooterCreator() {
            @Override
            public RefreshFooter createRefreshFooter(Context context, RefreshLayout layout) {
                ClassicsFooter classicsFooter = new ClassicsFooter(context);
                classicsFooter.setDrawableSize(20);
                classicsFooter.setFinishDuration(0);
                //指定为经典Footer，默认是 BallPulseFooter
                return classicsFooter;
            }
        });
    }

    @Override
    public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {

    }

    @Override
    public void onActivityStarted(@NonNull Activity activity) {
        AppLifecycleUtil.onAppFrontGround();

//        if (playId!=null && !playId.equals("")){
//            RetrofitClient.getInstance().userRoomBack(playId, "1");
//        }
    }

    @Override
    public void onActivityResumed(@NonNull Activity activity) {
        if (activityCount == 0) {
            // 应用从后台回到前台
            if (appStateListener != null) {
                appStateListener.onAppForeground();
            }
//            handleAppForeground(activity);
//            AppStateManager.setRoomActivityMinimized(false);
            AppLifecycleUtil.onAppFrontGround();
        }
        if (playId!=null && !playId.equals("")){
            RetrofitClient.getInstance().userRoomBack(playId, "2");
        }
        activityCount++;
    }

    @Override
    public void onActivityPaused(@NonNull Activity activity) {
        activityCount--;
        if (activityCount == 0) {
            // 应用切换到后台
            if (appStateListener != null) {
                appStateListener.onAppBackground();
            }

            if (playId!=null && !playId.equals("")){
                RetrofitClient.getInstance().userRoomBack(playId, "1");
            }

            AppLifecycleUtil.onAppBackGround();
//            handleAppBackground(activity);
//            AppStateManager.setRoomActivityMinimized( true);
        }
    }

    private void handleAppBackground(Activity activity) {
        String className = activity.getClass().getName();
        if (className.contains("RoomActivity") && appStateListener != null) {
            // RoomActivity进入后台时显示悬浮窗
            appStateListener.setFloatingWindowVisible(true);
        }
    }
    private void handleAppForeground(Activity activity) {
        // 获取当前Activity的类名，避免直接引用类
        String className = activity.getClass().getName();

        if (className.contains("LaunchPageActivity")) {
            // 对于启动页，我们需要检查是否应该跳转到主页面
            if (appStateListener != null && appStateListener.isFloatingWindowVisible()) {
                // 有悬浮窗，直接回到首页
                ARouter.getInstance().build(ARouteConstants.ME).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP).navigation();
            } else if (appStateListener != null && appStateListener.shouldShowSplash()) {
                // 需要显示启动页，但已经在启动页了，不需要额外操作
                return;
            } else {
                // 默认情况下，跳转到主页面
                ARouter.getInstance().build(ARouteConstants.ME).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP).navigation();
            }
            return; // 启动页或引导页不需要特殊处理
        }

        if (appStateListener != null && appStateListener.isFloatingWindowVisible()) {
            // 有悬浮窗，直接回到首页
//            if (!className.contains("MainActivity")) {
                ARouter.getInstance().build(ARouteConstants.ME).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP).navigation();
//            }
        } else if (appStateListener != null && appStateListener.shouldShowSplash()) {
            // 需要显示启动页
            try {
                Class<?> splashActivityClass = Class.forName("com.xscm.modulemain.activity.LaunchPageActivity");
                Intent intent = new Intent(activity, splashActivityClass);
                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
                activity.startActivity(intent);

            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    private void showFloatingWindow(Activity activity) {
        // 这里实现显示悬浮窗的逻辑
        AppStateManager.getInstance().setFloatingWindowVisible(true);
        // 实际显示悬浮窗的代码，已实现
    }

    @Override
    public void onActivityStopped(@NonNull Activity activity) {

    }

    @Override
    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {

    }

    @Override
    public void onActivityDestroyed(@NonNull Activity activity) {
//        String className = activity.getClass().getName();
//        if (className.contains("RoomActivity") && appStateListener != null) {
//            appStateListener.onRoomActivityDestroyed();
//        }
    }

    @Override
    public void onTerminate() {
        super.onTerminate();
        LogUtils.e("@@@", "onTerminate");
    }
}