夜猫麻将 v24.1.1 - TMGContext.java 源代码

package com.gme.TMG;

import android.content.Context;
import android.content.Intent;
import com.gme.TMG.ITMGContext;
import com.gme.TMG.TMGRoom;
import com.gme.TMG.advance.TMGAudioRecordCtrl;
import com.gme.av.sdk.AVError;
import com.gme.av.utils.QLog;
import com.gme.av.wrapper.OpensdkGameWrapper;
import java.util.ArrayList;
import java.util.List;
import org.json.JSONException;
import org.json.JSONObject;

public class TMGContext extends ITMGContext {
    private static final String TAG = "TMGContext";
    private OpensdkGameWrapper gameWrapper;
    Context mContext;
    private boolean sdk_match;
    public ITMGContext.ITMGDelegate mTmgDelegate = null;
    TMGRoom mRoom = new TMGRoom(this);
    TMGRoomManager mRoomManager = new TMGRoomManager(this);
    TMGAudioCtrl mAudioCtrl = new TMGAudioCtrl(this);
    TMGPTT mPTT = new TMGPTT(this);
    TMGAudioEffectCtrl mEffectCtrl = new TMGAudioEffectCtrl(this);
    List<String> mLstUinSpeaking = new ArrayList();
    TMGRoom.EventListener mRoomEventListener = new TMGRoom.EventListener() {
        @Override
        public void onEnterRoomComplete(int nRet, String strErrMsg) {
            if (TMGContext.this.mTmgDelegate != null) {
                Intent it = TMGCallbackHelper.GetCallBackIntent(nRet, strErrMsg);
                TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_ENTER_ROOM, it);
            }
        }

        @Override
        public void onExitRoomComplete() {
            TMGContext.this.mAudioCtrl.StopTrackingVolume();
            TMGContext.this.mLstUinSpeaking.clear();
            if (TMGContext.this.mTmgDelegate != null) {
                Intent it = TMGCallbackHelper.GetCallBackIntent(0, "");
                TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_EXIT_ROOM, it);
            }
        }

        @Override
        public void onRoomDisconnect(int nRet, String strErrMsg) {
            if (TMGContext.this.mTmgDelegate != null) {
                Intent it = TMGCallbackHelper.GetCallBackIntent(nRet, strErrMsg);
                TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_ROOM_DISCONNECT, it);
            }
        }

        @Override
        public void onEndpointsUpdateInfo(int eventId, String[] identifierList) {
            if (TMGContext.this.mTmgDelegate != null) {
                int Type = 0;
                if (eventId == 1) {
                    Type = 1;
                } else if (eventId != 2) {
                    if (eventId == 5) {
                        Type = 5;
                    } else if (eventId == 6) {
                        Type = 6;
                    }
                } else {
                    Type = 2;
                }
                for (String strUin : identifierList) {
                    if (Type == 5) {
                        if (!TMGContext.this.mLstUinSpeaking.contains(strUin)) {
                            TMGContext.this.mLstUinSpeaking.add(strUin);
                        }
                    } else if (TMGContext.this.mLstUinSpeaking.contains(strUin)) {
                        TMGContext.this.mLstUinSpeaking.remove(strUin);
                    }
                }
                if (Type != 0) {
                    Intent it = TMGCallbackHelper.GetUpdateInfoIntent(Type, identifierList);
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVNET_TYPE_USER_UPDATE, it);
                }
            }
        }

        @Override
        public void onRoomEvent(int type, int subtype, Object eventObj) {
            if (type == 400) {
                int nNewState = ((Integer) eventObj).intValue();
                QLog.e(TMGContext.TAG, "AVRoomMultiDelegateJni TMGContext.onRoomEvent type = " + type + ", subtype = " + subtype + ", nNewState=" + nNewState);
                if (TMGContext.this.mTmgDelegate != null) {
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_CHANGE_ROOM_TYPE, TMGCallbackHelper.GetRoomTypeChangedEventIntent(0, subtype, nNewState, ""));
                    return;
                }
                return;
            }
            if (type == 401) {
                String StringDetail = (String) eventObj;
                QLog.e(TMGContext.TAG, "AVRoomMultiDelegateJni TMGContext.onRoomEvent type = " + type + ", ret=" + StringDetail);
                try {
                    int nRoomShareCode = new JSONObject(StringDetail).getInt("result");
                    QLog.d(TMGContext.TAG, "AVRoomMultiDelegateJni TMGContext.onRoomEvent , nRoomShareCode =" + String.valueOf(nRoomShareCode));
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_ROOM_SHARING_START, TMGCallbackHelper.GetRoomShareEventIntent(nRoomShareCode));
                    return;
                } catch (JSONException e) {
                    e.printStackTrace();
                    return;
                } catch (Exception e2) {
                    e2.printStackTrace();
                    return;
                }
            }
            if (type == 402) {
                String StringDetail2 = (String) eventObj;
                QLog.e(TMGContext.TAG, "AVRoomMultiDelegateJni TMGContext.onRoomEvent type = " + type + ", ret=" + StringDetail2);
                try {
                    int nRoomShareCode2 = new JSONObject(StringDetail2).getInt("result");
                    QLog.d(TMGContext.TAG, "AVRoomMultiDelegateJni TMGContext.onRoomEvent , nRoomShareCode =" + String.valueOf(nRoomShareCode2));
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_ROOM_SHARING_STOP, TMGCallbackHelper.GetRoomShareEventIntent(nRoomShareCode2));
                    return;
                } catch (JSONException e3) {
                    e3.printStackTrace();
                    return;
                } catch (Exception e4) {
                    e4.printStackTrace();
                    return;
                }
            }
            if (type == 450) {
                String StringDetail3 = (String) eventObj;
                try {
                    JSONObject jsonResult = new JSONObject(StringDetail3);
                    int nAllUser = jsonResult.getInt("AllUser");
                    int nAccUser = jsonResult.getInt("AccUser");
                    int nProxyUser = jsonResult.getInt("ProxyUser");
                    QLog.d(TMGContext.TAG, "AVRoomMultiDelegateJni TMGContext.onRoomEvent , AllUser=" + String.valueOf(nAllUser) + ", AccUser=" + String.valueOf(nAccUser) + ", ProxyUser=" + String.valueOf(nProxyUser));
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_NUMBER_OF_USERS_UPDATE, TMGCallbackHelper.GetNumeberOfUsersEventIntent(nAllUser, nAccUser, nProxyUser));
                    return;
                } catch (JSONException e5) {
                    e5.printStackTrace();
                    return;
                } catch (Exception e6) {
                    e6.printStackTrace();
                    return;
                }
            }
            if (type == 451) {
                String StringDetail4 = (String) eventObj;
                try {
                    int nAudioStreams = new JSONObject(StringDetail4).getInt("AudioStreams");
                    QLog.d(TMGContext.TAG, "AVRoomMultiDelegateJni TMGContext.onRoomEvent , AllUser=" + String.valueOf(nAudioStreams));
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_NUMBER_OF_AUDIOSTREAMS_UPDATE, TMGCallbackHelper.GetAudioStreamsEventIntent(nAudioStreams));
                    return;
                } catch (JSONException e7) {
                    e7.printStackTrace();
                    return;
                } catch (Exception e8) {
                    e8.printStackTrace();
                    return;
                }
            }
            if (type == 500) {
                String StringDetail5 = (String) eventObj;
                try {
                    JSONObject jsonResult2 = new JSONObject(StringDetail5);
                    int nWeight = jsonResult2.getInt("Weight");
                    double fLoss = jsonResult2.getDouble("Loss");
                    int nDelay = jsonResult2.getInt("Delay");
                    QLog.d(TMGContext.TAG, "AVRoomMultiDelegateJni TMGContext.onRoomEvent , nWeight=" + String.valueOf(nWeight) + ", Loss=" + String.valueOf(fLoss) + ", Delay=" + String.valueOf(nDelay));
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_CHANGE_ROOM_QUALITY, TMGCallbackHelper.GetBadQualityEventIntent(nWeight, fLoss, nDelay));
                    return;
                } catch (JSONException e9) {
                    e9.printStackTrace();
                    return;
                } catch (Exception e10) {
                    e10.printStackTrace();
                    return;
                }
            }
            if (type == 1000) {
                TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_RECONNECT_START, TMGCallbackHelper.GetCallBackIntent(subtype, ""));
                return;
            }
            if (type == 1001) {
                TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_RECONNECT_SUCCESS, TMGCallbackHelper.GetCallBackIntent(subtype, ""));
                return;
            }
            if (type == 1002) {
                String StringDetail6 = (String) eventObj;
                try {
                    String newStr = StringDetail6.replace(" ", "_");
                    JSONObject jsonResult3 = new JSONObject(newStr);
                    int result = jsonResult3.getInt("result");
                    String errorInfo = jsonResult3.getString("error_info");
                    Intent it = new Intent();
                    it.putExtra("result", result);
                    it.putExtra("error_info", errorInfo);
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_SWITCH_ROOM, it);
                    return;
                } catch (JSONException e11) {
                    e11.printStackTrace();
                    return;
                } catch (Exception e12) {
                    e12.printStackTrace();
                    return;
                }
            }
            if (type == 6000) {
                String StringDetail7 = (String) eventObj;
                try {
                    JSONObject jsonResult4 = new JSONObject(StringDetail7);
                    Intent it2 = new Intent();
                    String SenderID = jsonResult4.getString("SenderID");
                    String ReceiverID = jsonResult4.getString("ReceiverID");
                    String UUID = jsonResult4.getString("UUID");
                    boolean OperateValue = jsonResult4.getBoolean("OperateValue");
                    int Result = jsonResult4.getInt("Result");
                    it2.putExtra("SenderID", SenderID);
                    it2.putExtra("ReceiverID", ReceiverID);
                    it2.putExtra("UUID", UUID);
                    it2.putExtra("OperateValue", OperateValue);
                    it2.putExtra("Result", Result);
                    it2.putExtra("OperateType", subtype);
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVNET_TYPE_ROOM_MANAGEMENT_OPERATOR, it2);
                    return;
                } catch (JSONException e13) {
                    e13.printStackTrace();
                    return;
                } catch (Exception e14) {
                    e14.printStackTrace();
                    return;
                }
            }
            if (type == 403) {
                String StringDetail8 = (String) eventObj;
                try {
                    JSONObject jsonResult5 = new JSONObject(StringDetail8);
                    String errInfo = jsonResult5.getString("error_info");
                    int result2 = jsonResult5.getInt("result");
                    Intent it3 = new Intent();
                    it3.putExtra("result", result2);
                    it3.putExtra("error_info", errInfo);
                    it3.putExtra("sub_event", subtype);
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_SERVER_AUDIO_ROUTE_EVENT, it3);
                    return;
                } catch (JSONException e15) {
                    e15.printStackTrace();
                    return;
                } catch (Exception e16) {
                    e16.printStackTrace();
                    return;
                }
            }
            if (type == 404) {
                String StringDetail9 = (String) eventObj;
                try {
                    JSONObject jsonResult6 = new JSONObject(StringDetail9);
                    String content = jsonResult6.getString("content");
                    String senderid = jsonResult6.getString("senderid");
                    Intent it4 = new Intent();
                    it4.putExtra("content", content);
                    it4.putExtra("senderid", senderid);
                    it4.putExtra("sub_event", subtype);
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_CUSTOMDATA_UPDATE, it4);
                    return;
                } catch (JSONException e17) {
                    e17.printStackTrace();
                    return;
                } catch (Exception e18) {
                    e18.printStackTrace();
                    return;
                }
            }
            if (type == 407) {
                String StringDetail10 = (String) eventObj;
                try {
                    JSONObject jsonResult7 = new JSONObject(StringDetail10);
                    int result3 = jsonResult7.getInt("result");
                    Intent it5 = new Intent();
                    it5.putExtra("sub_event", subtype);
                    it5.putExtra("result", result3);
                    if (subtype == 1) {
                        it5.putExtra("slice_type", jsonResult7.getInt("slice_type"));
                        it5.putExtra("index", jsonResult7.getInt("index"));
                        it5.putExtra("voice_text_str", jsonResult7.getString("voice_text_str"));
                    } else {
                        it5.putExtra("error_info", jsonResult7.getString("error_info"));
                    }
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_REALTIME_ASR, it5);
                    return;
                } catch (JSONException e19) {
                    e19.printStackTrace();
                    return;
                } catch (Exception e20) {
                    e20.printStackTrace();
                    return;
                }
            }
            if (type == 408) {
                String StringDetail11 = (String) eventObj;
                try {
                    JSONObject jsonResult8 = new JSONObject(StringDetail11);
                    int result4 = jsonResult8.getInt("result");
                    int age_detected_result = jsonResult8.getInt("age_detected_result");
                    Intent it6 = new Intent();
                    it6.putExtra("age_detected_result", age_detected_result);
                    it6.putExtra("result", result4);
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_AGE_DETECTED, it6);
                    return;
                } catch (JSONException e21) {
                    e21.printStackTrace();
                    return;
                } catch (Exception e22) {
                    e22.printStackTrace();
                    return;
                }
            }
            if (type == 406) {
                String StringDetail12 = (String) eventObj;
                try {
                    JSONObject jsonResult9 = new JSONObject(StringDetail12);
                    String error_info = jsonResult9.getString("error_info");
                    int result5 = jsonResult9.getInt("ErrorCode");
                    String Accompanier_Openid = jsonResult9.getString("Accompanier_Openid");
                    Intent it7 = new Intent();
                    it7.putExtra("error_info", error_info);
                    it7.putExtra("result", result5);
                    it7.putExtra("Accompanier_Openid", Accompanier_Openid);
                    it7.putExtra("sub_type", subtype);
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_CHORUS_EVENT, it7);
                    return;
                } catch (JSONException e23) {
                    e23.printStackTrace();
                    return;
                } catch (Exception e24) {
                    e24.printStackTrace();
                    return;
                }
            }
            if (type == 452) {
                String StringDetail13 = (String) eventObj;
                try {
                    JSONObject jsonResult10 = new JSONObject(StringDetail13);
                    String error_info2 = jsonResult10.getString("error_info");
                    int result6 = jsonResult10.getInt("ErrorCode");
                    int teamid = jsonResult10.getInt("teamid");
                    Intent it8 = new Intent();
                    it8.putExtra("error_info", error_info2);
                    it8.putExtra("result", result6);
                    it8.putExtra("teamid", teamid);
                    it8.putExtra("sub_type", subtype);
                    TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_CHANGETEAMID, it8);
                } catch (JSONException e25) {
                    e25.printStackTrace();
                } catch (Exception e26) {
                    e26.printStackTrace();
                }
            }
        }

        @Override
        public void onDisableAudioIssue() {
            if (TMGContext.this.mTmgDelegate != null) {
                Intent it = new Intent();
                it.putExtra("reason", 65536);
                it.putExtra("error_info", "");
                TMGContext.this.mTmgDelegate.OnEvent(ITMGContext.ITMG_MAIN_EVENT_TYPE.ITMG_MAIN_EVENT_TYPE_AUDIO_DATA_EMPTY, it);
            }
        }
    };

    private native int nativeCheckMic();

    private native int nativeEnableAgeDectection(boolean z);

    private native int nativeEnterRoom(String str, int i, byte[] bArr, TMGRoom.EventListener eventListener);

    private native int nativeExitRoom();

    private native String nativeGetParam(String str);

    private native String nativeGetSDKVersion();

    private native int nativeInitAgeDectection(String str, String str2);

    private native int nativePause();

    private native int nativePoll();

    private native int nativeResume();

    private native int nativeSetAppVersion(String str);

    private native void nativeSetHost(String str, String str2);

    private native int nativeSetLogLevel(int i, int i2);

    private native int nativeSetLogPath(String str);

    private native int nativeSetParam(String str, String str2);

    private native void nativeSetRegion(String str);

    private native int nativeStart(String str, String str2);

    private native int nativeStartRealTimeASR(String str);

    private native int nativeStop();

    private native int nativeStopRealTimeASR();

    private native boolean nativeisRoomEntered();

    public native int nativeSetRangeAudioMode(int i);

    public native int nativeSetRangeAudioTeamID(int i);

    TMGContext(Context context) {
        this.gameWrapper = null;
        this.mContext = null;
        this.sdk_match = true;
        this.mContext = context;
        TMGAudioRecordCtrl.GetInstance().setTMGContext(this);
        OpensdkGameWrapper opensdkGameWrapper = new OpensdkGameWrapper(this.mContext);
        this.gameWrapper = opensdkGameWrapper;
        if (opensdkGameWrapper.initOpensdk() == 7015) {
            this.sdk_match = false;
        }
    }

    @Override
    public int Poll() {
        return nativePoll();
    }

    @Override
    public ITMGContext.ITMG_RECORD_PERMISSION CheckMicPermission() {
        if (this.gameWrapper != null) {
            return ITMGContext.ITMG_RECORD_PERMISSION.values()[this.gameWrapper.CheckMicPermission()];
        }
        QLog.e(TAG, "gameWrapper is not install");
        return ITMGContext.ITMG_RECORD_PERMISSION.ITMG_PERMISSION_ERROR;
    }

    @Override
    public ITMGContext.ITMG_CHECK_MIC_STATUS CheckMic() {
        int index = nativeCheckMic();
        QLog.d(TAG, "CheckMic = " + index);
        if (index >= 0 && index < ITMGContext.ITMG_CHECK_MIC_STATUS.values().length) {
            return ITMGContext.ITMG_CHECK_MIC_STATUS.values()[index];
        }
        return ITMGContext.ITMG_CHECK_MIC_STATUS.ITMG_CHECK_MIC_STATUS_ERROR_FUNC;
    }

    @Override
    public int Pause() {
        return nativePause();
    }

    @Override
    public int Resume() {
        return nativeResume();
    }

    @Override
    public int SetLogLevel(int levelWrite, int levelPrint) {
        return nativeSetLogLevel(levelWrite, levelPrint);
    }

    @Override
    public int SetLogPath(String logDir) {
        return nativeSetLogPath(logDir);
    }

    @Override
    public int Uninit() {
        this.mAudioCtrl.StopTrackingVolume();
        this.mLstUinSpeaking.clear();
        nativeStop();
        nativePoll();
        return 0;
    }

    @Override
    public int SetTMGDelegate(ITMGContext.ITMGDelegate delegate) {
        QLog.i("API", String.format("SetTMGDelegate.delegate=%s", delegate));
        this.mTmgDelegate = delegate;
        return 0;
    }

    @Override
    public void SetRegion(String region) {
        nativeSetRegion(region);
    }

    @Override
    public void SetHost(String chatHost, String pttHost) {
        nativeSetHost(chatHost, pttHost);
    }

    @Override
    public int Init(String sdkAppID, String openID) {
        this.mPTT.SetAppInfo(sdkAppID, openID);
        int ret = nativeStart(sdkAppID, openID);
        return this.sdk_match ? ret : AVError.AV_ERR_SDK_NOT_FULL_UPDATE;
    }

    @Override
    public String GetSDKVersion() {
        return nativeGetSDKVersion();
    }

    @Override
    public int SetRecvMixStreamCount(int nCount) {
        return nativeSetParam("RecvMixStreamCount", String.valueOf(nCount));
    }

    @Override
    public int SetAdvanceParams(String strKey, String strValue) {
        return nativeSetParam(strKey, strValue);
    }

    @Override
    public String GetAdvanceParams(String strKey) {
        return nativeGetParam(strKey);
    }

    @Override
    public void SetAppVersion(String sAppVersion) {
        nativeSetAppVersion(sAppVersion);
    }

    @Override
    public boolean IsRoomEntered() {
        return nativeisRoomEntered();
    }

    @Override
    public int EnterRoom(String roomID, int roomType, byte[] authBuffer) {
        return nativeEnterRoom(roomID, roomType, authBuffer, this.mRoomEventListener);
    }

    @Override
    public int SetRangeAudioMode(ITMGContext.ITMG_RANGE_AUDIO_MODE gameAudioMode) {
        int nType = gameAudioMode.getValue();
        return nativeSetRangeAudioMode(nType);
    }

    @Override
    public int SetRangeAudioTeamID(int teamID) {
        return nativeSetRangeAudioTeamID(teamID);
    }

    @Override
    public int ExitRoom() {
        this.mAudioCtrl.StopTrackingVolume();
        this.mLstUinSpeaking.clear();
        return exitRoom();
    }

    @Override
    public int StartRealTimeASR() {
        return nativeStartRealTimeASR("cmn-Hans-CN");
    }

    @Override
    public int StartRealTimeASR(String language) {
        return nativeStartRealTimeASR(language);
    }

    @Override
    public int StopRealTimeASR() {
        return nativeStopRealTimeASR();
    }

    @Override
    public int EnableAgeDectection(boolean bEnable) {
        return nativeEnableAgeDectection(bEnable);
    }

    @Override
    public int InitAgeDectection(String strBinaryPath, String strParamPath) {
        return nativeInitAgeDectection(strBinaryPath, strParamPath);
    }

    @Override
    public ITMGRoom GetRoom() {
        return this.mRoom;
    }

    @Override
    public ITMGRoomManager GetRoomManager() {
        return this.mRoomManager;
    }

    @Override
    public ITMGAudioCtrl GetAudioCtrl() {
        return this.mAudioCtrl;
    }

    @Override
    public ITMGAudioEffectCtrl GetAudioEffectCtrl() {
        return this.mEffectCtrl;
    }

    @Override
    public ITMGPTT GetPTT() {
        return this.mPTT;
    }

    public int exitRoom() {
        return nativeExitRoom();
    }
}