yusheng-android/moduleUtil/src/main/java/com/xscm/moduleutil/base/RoomManager.java

package com.xscm.moduleutil.base;

import static android.app.PendingIntent.getActivity;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;

import androidx.core.app.ActivityOptionsCompat;

import com.alibaba.android.arouter.facade.Postcard;
import com.alibaba.android.arouter.facade.callback.NavCallback;
import com.alibaba.android.arouter.launcher.ARouter;
import com.blankj.utilcode.util.ActivityUtils;
import com.blankj.utilcode.util.LogUtils;
import com.blankj.utilcode.util.ToastUtils;
import com.xscm.moduleutil.R;
import com.xscm.moduleutil.bean.room.RoomInfoResp;
import com.xscm.moduleutil.bean.room.RoomOnline;
import com.xscm.moduleutil.bean.room.RoomOnlineBean;
import com.xscm.moduleutil.event.RoomOutEvent;
import com.xscm.moduleutil.http.BaseObserver;
import com.xscm.moduleutil.http.RetrofitClient;
import com.xscm.moduleutil.listener.MessageListenerSingleton;
import com.xscm.moduleutil.rtc.AgoraManager;
import com.xscm.moduleutil.utils.ARouteConstants;
import com.xscm.moduleutil.utils.SpUtil;
import com.xscm.moduleutil.utils.logger.Logger;

import org.greenrobot.eventbus.EventBus;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import io.reactivex.disposables.Disposable;
import org.jetbrains.annotations.NotNull;

/**
 * 房间管理器
 * 统一处理房间数据获取、进入房间和退出房间的逻辑
 */
public class RoomManager {
    private static final String TAG = "RoomManager";

    private static RoomManager instance;

    // 房间数据缓存
    private Map<String, RoomInfoResp> roomDataCache = new ConcurrentHashMap<>();
    private Map<String, Long> cacheTimestamps = new ConcurrentHashMap<>();

    // 缓存有效期（5分钟）
    private static final long CACHE_DURATION = 5 * 60 * 1000;

    private RoomManager() {
    }

    public static synchronized RoomManager getInstance() {
        if (instance == null) {
            instance = new RoomManager();
        }
        return instance;
    }

    /**
     * 进入房间 - 自动获取房间数据
     *
     * @param context 上下文
     * @param roomId  房间ID
     */
    public void enterRoom(Context context, String roomId) {
        enterRoom(context, roomId, null, null);
    }

    /**
     * 进入房间 - 使用密码
     *
     * @param context  上下文
     * @param roomId   房间ID
     * @param password 房间密码
     */
    public void enterRoom(Context context, String roomId, String password) {
        enterRoom(context, roomId, password, null);
    }

    /**
     * 进入房间 - 使用缓存数据
     *
     * @param context    上下文
     * @param roomId     房间ID
     * @param password   房间密码
     * @param cachedData 缓存的房间数据
     */
    public void enterRoom(Context context, String roomId, String password, RoomInfoResp cachedData) {
        if (TextUtils.isEmpty(roomId)) {
            ToastUtils.showShort("房间ID不能为空");
            return;
        }

        // 检查是否有有效的缓存数据
        RoomInfoResp roomInfo = cachedData != null ? cachedData : getCachedRoomData(roomId);

        if (roomInfo != null) {
            // 使用缓存数据直接进入房间
            navigateToRoom(context, roomId, password, roomInfo, false,null);
        } else {
            // 获取房间数据后进入房间
            fetchRoomDataAndEnter(context, roomId, password,null);
        }
    }

    /**
     * 获取房间数据并进入房间
     *
     * @param context  上下文
     * @param roomId   房间ID
     * @param password 房间密码
     */
    public void fetchRoomDataAndEnter(Context context, String roomId, String password,String taskId) {
        // 显示加载提示
        // 这里可以根据需要添加加载对话框
        if (CommonAppContext.getInstance().isRoomJoininj){
            return;
        }

        CommonAppContext.getInstance().isRoomJoininj=true;
        // 检查是否有有效的缓存数据
        RoomInfoResp roomInfo =  getCachedRoomData(roomId);
        // 检查是否是当前房间且用户在线
//        boolean isCurrentRoom = isCurrentRoom(roomId);
        if (CommonAppContext.getInstance().playId == null) {
            fetchAndJoinRoom(context, roomId, password,taskId);
        } else {
            if (!CommonAppContext.getInstance().playId.equals(roomId)) {
                MessageListenerSingleton.getInstance().joinGroup(roomId);
                exitRoom(CommonAppContext.getInstance().playId);
                CommonAppContext.getInstance().isShow = false;
                CommonAppContext.getInstance().isPlaying = false;
                CommonAppContext.getInstance().isRoomJoininj=false;
                EventBus.getDefault().post(new RoomOutEvent());
//                fetchAndJoinRoom(context, roomId, password);
//                return;
            } else if (CommonAppContext.getInstance().lable_id.equals("6")) {
                upInfo(context, roomId, password, true, roomInfo, true,taskId);
                return;
            }
            isUserOnline(context, roomId, password, roomInfo,taskId);

        }

//        try {
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
//            Thread.currentThread().interrupt();
//        }

        // 如果是当前房间且用户在线，直接跳转到房间页面，仅更新数据


//        // 获取房间数据
//        MessageListenerSingleton.getInstance().joinGroup(roomId);
//        // 等待一段时间确保退出完成
//        try {
//            Thread.sleep(500);
//        } catch (InterruptedException e) {
//            Thread.currentThread().interrupt();
//        }
//        RetrofitClient.getInstance().roomGetIn(roomId, password, new BaseObserver<RoomInfoResp>() {
//
//            @Override
//            public void onSubscribe(Disposable d) {
//            }
//
//            @Override
//            public void onNext(RoomInfoResp resp) {
//                String appId = CommonAppContext.getInstance().getCurrentEnvironment().getSwSdkAppId();
//                String token = resp.getUser_info().getAgora_token(); // 如果启用了鉴权才需要
//                String roomId = resp.getRoom_info().getRoom_id(); // 房间 ID
//                String rtm_token=resp.getUser_info().getAgora_rtm_token();
//                SpUtil.setRtmToken(rtm_token);
//                int uid = SpUtil.getUserId(); // 0 表示由 Agora 自动生成 UID
//                boolean enableMic = false; // 是否开启麦克风
//                boolean enableJs=false; // 是否开启角色
//                if (resp.getUser_info().getPit_number()!=0){
//                    enableJs=true;
//                }
//                LogUtils.e("token",token);
//                LogUtils.e("roomId:",roomId);
//// 初始化 Agora 并加入房间
//                AgoraManager.getInstance(context)
//                        .joinRoom(token, roomId, uid, enableMic,enableJs);
//                cacheRoomData(roomId, resp);
//                navigateToRoom(context, roomId, password, resp);
//            }
//        });

        // 临时实现 - 直接跳转（因为缺少具体的网络请求代码）
//        navigateToRoom(context, roomId, password, null);
    }

    private void upInfo(Context context, String roomId, String password, boolean isOnline, RoomInfoResp roomInfo, boolean isCurrentRoom,String taskId) {


        if (isOnline) {
            RetrofitClient.getInstance().postRoomInfo(roomId, new BaseObserver<RoomInfoResp>() {

                @Override
                public void onSubscribe(@NotNull Disposable disposable) {

                }

                @Override
                public void onNext(@NotNull RoomInfoResp roomInfoResp) {
                    navigateToRoom(context, roomId, password, roomInfoResp, false,taskId);
                }
            });
//            navigateToRoom(context, roomId, password, roomInfo, isOnline);
        } else {
            fetchAndJoinRoom(context, roomId, password,taskId);
        }
    }

    /**
     * 获取新的房间数据并加入房间
     *
     * @param context  上下文
     * @param roomId   房间ID
     * @param password 房间密码
     */
    private void fetchAndJoinRoom(Context context, String roomId, String password,String taskId) {
        // 获取房间数据

        // 等待一段时间确保退出完成
//        try {
//            Thread.sleep(50);
//        } catch (InterruptedException e) {
//            Thread.currentThread().interrupt();
//        }
//        navigateToRoom(context, roomId, password, null, false);
        RetrofitClient.getInstance().roomGetIn(roomId, password, new BaseObserver<RoomInfoResp>() {

            @Override
            public void onSubscribe(Disposable d) {
            }

            @Override
            public void onNext(RoomInfoResp resp) {
                if (resp!=null) {
                    String appId = CommonAppContext.getInstance().getCurrentEnvironment().getSwSdkAppId();
                    String token = resp.getUser_info().getAgora_token(); // 如果启用了鉴权才需要
                    String roomId = resp.getRoom_info().getRoom_id(); // 房间 ID
                    String rtm_token = resp.getUser_info().getAgora_rtm_token();
                    SpUtil.setRtmToken(rtm_token);
                    int uid = SpUtil.getUserId(); // 0 表示由 Agora 自动生成 UID
                    boolean enableMic = false; // 是否开启麦克风
                    boolean enableJs = false; // 是否开启角色
                    if (resp.getUser_info().getPit_number() != 0) {
                        enableJs = true;
                    }
                    LogUtils.e("token", token);
                    LogUtils.e("roomId:", roomId);
// 初始化 Agora 并加入房间
                    AgoraManager.getInstance(context)
                            .joinRoom(token, roomId, uid, enableMic, enableJs);
                    cacheRoomData(roomId, resp);
                    navigateToRoom(context, roomId, password, resp, false, taskId);
                }else {

                }
            }

            @Override
            public void onError(Throwable e) {
                super.onError(e);
            }
        });
    }

    /**
     * 检查是否是当前房间
     *
     * @param roomId 房间ID
     * @return true表示是当前房间，false表示不是
     */
    private boolean isCurrentRoom(String roomId) {
        // 这里应该实现检查是否是当前房间的逻辑
        // 可以通过检查当前Activity或者通过全局变量等方式实现
        // 目前返回false，需要根据实际需求实现具体逻辑

        RoomInfoResp roomInfo = getCachedRoomData(roomId);
        if (roomInfo != null) {
            if (roomInfo.getRoom_info().getRoom_id().equals(roomId)) {
                return true;
            } else {
                return false;
            }
        }

        return false;
    }

    /**
     * 跳转到房间页面
     *
     * @param context  上下文
     * @param roomId   房间ID
     * @param password 房间密码
     * @param roomInfo 房间信息
     */
    private void navigateToRoom(Context context, String roomId, String password, RoomInfoResp roomInfo, boolean isOnline,String taskId) {

        try {
            // 构建跳转参数
            Bundle bundle = new Bundle();
            bundle.putString("roomId", roomId);
            bundle.putBoolean("isOnline", isOnline);
            bundle.putSerializable("roomInfo", roomInfo);
            if (!TextUtils.isEmpty(password)) {
                bundle.putString("password", password);
            }
            if (taskId != null){
                bundle.putString("taskId", taskId);
            }

            if (roomInfo == null){
                LogUtils.dTag("RoomActivity", "navigateToRoom:房间信息获取存在问题");
                return;
            }

                // 使用ARouter跳转到房间页面
                ARouter.getInstance()
                        .build(ARouteConstants.ROOM_DETAILS)
                        .with(bundle)
                        .withFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
                        .navigation(context);
        } catch (Exception e) {
            Logger.e(TAG, "跳转房间页面失败: " + e.getMessage());
        }finally {
        }
    }

    /**
     * 缓存房间数据
     *
     * @param roomId   房间ID
     * @param roomInfo 房间信息
     */
    public void cacheRoomData(String roomId, RoomInfoResp roomInfo) {

        if (TextUtils.isEmpty(roomId) || roomInfo == null) {
            return;
        }
        // 清除所有现有的缓存数据
        roomDataCache.clear();
        cacheTimestamps.clear();
        roomDataCache.put(roomId, roomInfo);
        cacheTimestamps.put(roomId, System.currentTimeMillis());
    }

    /**
     * 获取缓存的房间数据
     *
     * @param roomId 房间ID
     * @return 房间信息，如果缓存无效则返回null
     */
    public RoomInfoResp getCachedRoomData(String roomId) {
        if (TextUtils.isEmpty(roomId)) {
            return null;
        }

        Long timestamp = cacheTimestamps.get(roomId);
        if (timestamp == null) {
            return null;
        }

        // 检查缓存是否过期
        if (System.currentTimeMillis() - timestamp > CACHE_DURATION) {
            // 缓存过期，清除数据
            roomDataCache.remove(roomId);
            cacheTimestamps.remove(roomId);
            return null;
        }

        return roomDataCache.get(roomId);
    }

    /**
     * 检查用户是否在线
     *
     * @param roomId 房间ID
     * @return true表示用户在线，false表示不在线
     */
    private boolean isUserOnline(Context context, String roomId, String password, RoomInfoResp roomInfo,String taskId) {
        // 这里应该实现检查用户是否在线的逻辑
        // 可以通过检查Agora是否还在房间中，或者通过服务端接口查询用户状态等方式实现
        // 目前返回false，需要根据实际需求实现具体逻辑
//        boolean isCurrentRoom=isCurrentRoom(roomId);
//        try {
//            Thread.sleep(300);
//        } catch (InterruptedException e) {
//            Thread.currentThread().interrupt();
//        }



        final boolean[] isOnline = {false};
        RetrofitClient.getInstance().getRoomOnline(roomId, "1", "50", new BaseObserver<RoomOnline>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(RoomOnline roomOnline) {
                try {
                    if (roomOnline != null) {
                        if (roomOnline.getOn_pit() != null) {
                            for (RoomOnlineBean roomOnlineBean : roomOnline.getOn_pit()) {
                                if (roomOnlineBean.getUser_id() == SpUtil.getUserId()) {
                                    isOnline[0] = true;
                                    break;
                                }
                            }
                        }
                        if (roomOnline.getOff_pit() != null) {
                            for (RoomOnlineBean roomOnlineBean : roomOnline.getOff_pit()) {
                                if (roomOnlineBean.getUser_id() == SpUtil.getUserId()) {
                                    isOnline[0] = true;
                                    break;
                                }
                            }
                        }
                        upInfo(context, roomId, password, isOnline[0], roomInfo, true, taskId);

                    } else {
                        isOnline[0] = false;
                    }
                } catch (Exception e) {
                    // 捕获所有可能的异常，避免崩溃
                    e.printStackTrace();
                    isOnline[0] = false;
                    // 即使出现异常也继续执行
                    upInfo(context, roomId, password, isOnline[0], roomInfo, true, taskId);
                }
            }
        });
        return false;
    }

    /**
     * 清除指定房间的缓存数据
     *
     * @param roomId 房间ID
     */
    public void clearRoomCache(String roomId) {
        if (!TextUtils.isEmpty(roomId)) {
            roomDataCache.remove(roomId);
            cacheTimestamps.remove(roomId);
        }
    }

    /**
     * 清除所有房间缓存数据
     */
    public void clearAllRoomCache() {
        roomDataCache.clear();
        cacheTimestamps.clear();
    }

    /**
     * 退出房间
     *
     * @param roomId 房间ID
     */
    public void exitRoom(String roomId) {
        // 清除该房间的缓存数据
        clearRoomCache(roomId);

        // 可以在这里添加其他退出房间的逻辑
        // 例如：通知服务器用户已退出、清理房间相关资源等

        RetrofitClient.getInstance().quitRoom(roomId, SpUtil.getUserId() + "", new BaseObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {

            }
        });

        Logger.d(TAG, "退出房间: " + roomId);
    }

    /**
     * 批量退出房间
     *
     * @param roomIds 房间ID列表
     */
    public void exitRooms(String... roomIds) {
        if (roomIds != null) {
            for (String roomId : roomIds) {
                exitRoom(roomId);
            }
        }
    }

    /**
     * 获取房间缓存状态
     *
     * @param roomId 房间ID
     * @return 缓存状态信息
     */
    public String getRoomCacheStatus(String roomId) {
        if (TextUtils.isEmpty(roomId)) {
            return "无效的房间ID";
        }

        Long timestamp = cacheTimestamps.get(roomId);
        if (timestamp == null) {
            return "未缓存";
        }

        long elapsed = System.currentTimeMillis() - timestamp;
        if (elapsed > CACHE_DURATION) {
            return "缓存已过期";
        }

        RoomInfoResp data = roomDataCache.get(roomId);
        if (data == null) {
            return "缓存数据为空";
        }

        return String.format("已缓存 (%d秒前)", elapsed / 1000);
    }
}