暖暖视频免费观**,国产免费美女被艹视频,毛片一级毛片,不卡三级

void onEvtAuthSuccess(long userId, TsdkImLoginParam imLoginParam); 

//Java code
public void onEvtAuthSuccess(int userId, TsdkImLoginParam imAccountLoginParam) {
    LogUtil.e(TAG, "authorize success.");
    // 啟動(dòng)IM的登錄
    if (TsdkManager.getInstance().getAppInfo().getSupportIm() == 1 && null != imLoginParam) {
        ImAccountInfo imAccountInfo = new ImAccountInfo();
        imAccountInfo.setAccount(imLoginParam.getAccount());
        imAccountInfo.setToken(imLoginParam.getToken());
        String[] MaaUri = imLoginParam.getMaaServerUri().split(":");
        imAccountInfo.setMaaServer(MaaUri[0]);
        imAccountInfo.setMaaServerPort(Integer.valueOf(MaaUri[1]));
        imAccountInfo.setPassword(imLoginParam.getPassword());
        imAccountInfo.setPushServer(imLoginParam.getPushServerUri());

        sendHandlerMessage(LoginEvent.LOGIN_E_EVT_AUTH_SUCCESS.getIndex(), imAccountInfo);
    }
}

void onEvtAuthFailed(long userId, TsdkCommonResult result); 

//Java code
public void onEvtAuthFailed(int userId, TsdkCommonResult result) {
    LogUtil.e(TAG, "authorize failed: " + result.getReasonDescription());
    this.loginEventNotifyUI.onLoginEventNotify(LoginConstant.LoginUIEvent.LOGIN_FAILED, result.getResult(), result.getReasonDescription());
}

void onEvtAuthRefreshFailed(long userId, TsdkCommonResult result); 

//Java code
public void onEvtAuthRefreshFailed(int userId, TsdkCommonResult result) {
    LogUtil.e(TAG, "refresh token failed:" + result.getReasonDescription());

    this.logout();
    this.loginEventNotifyUI.onLoginEventNotify(LoginConstant.LoginUIEvent.LOGOUT, 0, result.getReasonDescription());

}

void onEvtLoginSuccess(long userId, TsdkServiceAccountType serviceAccountType, TsdkLoginSuccessInfo loginSuccessInfo);

//Java code
public void onEvtLoginSuccess(int userId, TsdkServiceAccountType serviceAccountType, TsdkLoginSuccessInfo loginSuccessInfo) {
        Log.i(TAG, "onEvtLoginSuccess notify.");
        LoginMgr.getInstance().handleLoginSuccess(userId, serviceAccountType, loginSuccessInfo);
    }

void onEvtLoginFailed(long userId, TsdkServiceAccountType serviceAccountType, TsdkLoginFailedInfo loginFailedInfo);

//Java code
public void onEvtLoginFailed(int userId, TsdkServiceAccountType serviceAccountType, TsdkLoginFailedInfo loginFailedInfo) {
        Log.i(TAG, "onEvtLoginFailed notify.");
        LoginMgr.getInstance().handleLoginFailed(userId, serviceAccountType, loginFailedInfo);
    }

void onEvtLogoutSuccess(long userId, TsdkServiceAccountType serviceAccountType); 

//Java code
public void onEvtLogoutSuccess(int userId, TsdkServiceAccountType serviceAccountType) {
        Log.i(TAG, "onEvtLogoutSuccess notify.");
        LoginMgr.getInstance().handleLogoutSuccess(userId, serviceAccountType);
    }

//Java code
public void handleLogoutFailed(int userId, TsdkCommonResult result) {
        LogUtil.e(TAG, "logout failed: " + result.getReasonDescription());
    }

void onEvtForceLogout(long userId, TsdkServiceAccountType serviceAccountType, TsdkForceLogoutInfo forceLogoutInfo); 

//Java code
public void onEvtForceLogout(int userId, TsdkServiceAccountType serviceAccountType, TsdkForceLogoutInfo forceLogoutInfo) {
        Log.i(TAG, "onEvtForceLogout notify.");
        LoginMgr.getInstance().handleForceLogout(userId);
    }

void onEvtVoipAccountStatus(long userId, TsdkVoipAccountInfo voipAccountInfo); 

//Java code
public void onEvtVoipAccountStatus(int userId, TsdkVoipAccountInfo voipAccountInfo ) {
    LogUtil.e(TAG, "voip account status: " );

    this.sipNumber = voipAccountInfo.getNumber();
    if (!voipAccountInfo.getTerminal().equals("")) {
        this.terminal = voipAccountInfo.getTerminal();
    }
}

void onEvtFirewallDetectFailed(long userId, TsdkCommonResult result);

//Java code
public void handleFirewallDetectFailed(int userId, TsdkCommonResult result) {
        LogUtil.e(TAG, "firewall detect failed: " + result.getReasonDescription());
        this.loginEventNotifyUI.onLoginEventNotify(LoginConstant.LoginUIEvent.FIREWALL_DETECT_FAILED, result.getResult(), result.getReasonDescription());
    }

void onEvtBuildStgTunnelFailed(long userId, TsdkCommonResult result);

//Java code
public void handleBuildStgTunnelFailed(int userId, TsdkCommonResult result) {
        LogUtil.e(TAG, "build stg failed: " + result.getReasonDescription());
        this.loginEventNotifyUI.onLoginEventNotify(LoginConstant.LoginUIEvent.BUILD_STG_FAILED, result.getResult(), result.getReasonDescription());
    }

void onEvtSecurityTunnelInfoInd(long userId, long firewallMode, TsdkSecurityTunnelInfo securityTunnelInfo); 

//Java code
public void handleSecurityTunnelInfoInd(int userId, int firewallMode, TsdkSecurityTunnelInfo securityTunnelInfo) {
        LogUtil.i(TAG, "security tunnel info: " + userId + firewallMode);

    }

void onEvtModifyPasswordResult(long userId, TsdkCommonResult result);

//Java code
@Override
public void onEvtModifyPasswordResult(int userId, final TsdkCommonResult result) {
	Log.i(TAG, "onEvtModifyPasswordResult notify.");
	LoginMgr.getInstance().handModifyPasswordResult(result);
}

void onEvtLoginResumingInd(long userId);

//Java code
@Override
public void onEvtLoginResumingInd(long userId) {
	LogUtil.i(TAG, "onEvtLoginResumingInd notify.");
	LoginMgr.getInstance().handLoginResumingInd((int)userId);
}

void onEvtLoginResumeResult(long userId, TsdkCommonResult result);

//Java code
@Override
public void onEvtLoginResumeResult(long userId, TsdkCommonResult result) {
	LogUtil.i(TAG, "onEvtLoginResumeResult notify.");
	LoginMgr.getInstance().handLoginResumeResult(result);
}

void onEvtCallStartResult(TsdkCall call, TsdkCommonResult result); 

//Java code
None

void onEvtCallIncoming(TsdkCall call, Boolean maybeVideoCall); 

//Java code
public void onEvtCallIncoming(TsdkCall call, Boolean maybeVideoCall){
    Log.i(TAG, "onCallComing");
    if (null == call)
    {
        Log.e(TAG, "onCallComing call is null");
        return;
    }
    Session newSession = new Session(call);
    putCallSessionToMap(newSession);

    CallInfo callInfo = getCallInfo(call);
    callInfo.setMaybeVideoCall(maybeVideoCall);

    mCallNotification.onCallEventNotify(CallConstant.CallEvent.CALL_COMING, callInfo);
}

void onEvtCallOutgoing(TsdkCall call); 

//Java code
public void onEvtCallOutgoing(TsdkCall call){
    Log.i(TAG, "onCallGoing");
    if (null == call)
    {
        Log.e(TAG, "tupCall obj is null");
        return;
    }
    CallInfo callInfo = getCallInfo(call);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.CALL_GOING, callInfo);
}

void onEvtCallRingback(TsdkCall call); 

//Java code
public void onEvtCallRingback(TsdkCall call){
    Log.i(TAG, "onCallRingBack");
    if (null == call)
    {
        Log.e(TAG, "onCallRingBack call is null");
        return;
    }
        if (null != mCallNotification)
        {
            mCallNotification.onCallEventNotify(CallConstant.CallEvent.PLAY_RING_BACK_TONE, null);
        }
}

void onEvtCallRtpCreated(TsdkCall call); 

//Java code
public void onEvtCallRtpCreated(TsdkCall call){
    Log.i(TAG, "onCallRTPCreated");
    if (null == call)
    {
        Log.e(TAG, "tupCall obj is null");
        return;
    }

    CallInfo callInfo = getCallInfo(call);

    mCallNotification.onCallEventNotify(CallConstant.CallEvent.RTP_CREATED, callInfo);
}

void onEvtCallConnected(TsdkCall call); 

//Java code
public void onEvtCallConnected(TsdkCall call){
    Log.i(TAG, "onCallConnected");
    if (null == call)
    {
        Log.e(TAG, "call obj is null");
        return;
    }

    CallInfo callInfo = getCallInfo(call);
    Session callSession = getCallSessionByCallID(call.getCallInfo().getCallId());
    if (callSession == null)
    {
        Log.e(TAG, "call session obj is null");
        return;
    }

    if (callInfo.isVideoCall())
    {
        callSession.setCallStatus(CallConstant.CallStatus.VIDEO_CALLING);
    }
    else
    {
        callSession.setCallStatus(CallConstant.CallStatus.AUDIO_CALLING);
    }

    mCallNotification.onCallEventNotify(CallConstant.CallEvent.CALL_CONNECTED, callInfo);
}

void onEvtCallEnded(TsdkCall call); 

//Java code
public void onEvtCallEnded(TsdkCall call){
    Log.i(TAG, "onCallEnded");
    if (null == call)
    {
        Log.e(TAG, "onCallEnded call is null");
        return;
    }
    CallInfo callInfo = getCallInfo(call);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.CALL_ENDED, callInfo);
}

void onEvtCallDestroy(TsdkCall call); 

//Java code
public void onEvtCallDestroy(TsdkCall call){
    Log.i(TAG, "onCallDestroy");
    if (null == call)
    {
        Log.e(TAG, "call obj is null");
        return;
    }
    Session callSession = getCallSessionByCallID(call.getCallInfo().getCallId());
    if (callSession == null)
    {
        Log.e(TAG, "call session obj is null");
        return;
    }

    //從會(huì)話列表中移除一路會(huì)話
    removeCallSessionFromMap(callSession);
}

void onEvtOpenVideoReq(TsdkCall call, TsdkVideoOrientation orientType); 

//Java code
public void onEvtOpenVideoReq(TsdkCall call, TsdkVideoOrientation orientType){
    Log.i(TAG, "onCallAddVideo");
    if (null == call)
    {
        Log.e(TAG, "onCallAddVideo tupCall is null");
        return;
    }

    //音頻轉(zhuǎn)視頻
    Session callSession = getCallSessionByCallID(call.getCallInfo().getCallId());
    if (callSession == null)
    {
        Log.e(TAG, "call session obj is null");
        return;
    }

    CallConstant.CallStatus callStatus = callSession.getCallStatus();
    boolean isSupportVideo = isSupportVideo();

    if ((!isSupportVideo) || (CallConstant.CallStatus.AUDIO_CALLING != callStatus))
    {
        callSession.rejectAddVideo();
        return;
    }

    mCallNotification.onCallEventNotify(CallConstant.CallEvent.RECEIVED_REMOTE_ADD_VIDEO_REQUEST, null);

}

void onEvtRefuseOpenVideoInd(TsdkCall call); 

//Java code
public void onEvtRefuseOpenVideoInd(TsdkCall call){

    VideoMgr.getInstance().clearCallVideo();

    Session callSession = getCallSessionByCallID(call.getCallInfo().getCallId());
    callSession.setCallStatus(CallConstant.CallStatus.AUDIO_CALLING);

    CallInfo callInfo = getCallInfo(call);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.REMOTE_REFUSE_ADD_VIDEO_SREQUEST, callInfo);

}

void onEvtCloseVideoInd(TsdkCall call); 

//Java code
public void onEvtCloseVideoInd(TsdkCall call){
    if (null == call)
    {
        Log.e(TAG, "onCallDelVideo tupCall is null");
        return;
    }

    Session callSession = getCallSessionByCallID(call.getCallInfo().getCallId());
    if (callSession == null)
    {
        Log.e(TAG, "call session obj is null");
        return;
    }

    callSession.setCallStatus(CallConstant.CallStatus.AUDIO_CALLING);

    //Clear video data
    VideoMgr.getInstance().clearCallVideo();

    if (null != mCallNotification)
    {
        CallInfo callInfo = getCallInfo(call);
        mCallNotification.onCallEventNotify(CallConstant.CallEvent.CLOSE_VIDEO, callInfo);
    }

    if (callSession.isVideoHold())
    {
        callSession.holdCall();
    }
}

void onEvtOpenVideoInd(TsdkCall call); 

//Java code
public void onEvtOpenVideoInd(TsdkCall call){
    int isVideo = call.getCallInfo().getIsVideoCall(); // 1:video, 0: audio
    int callId  = call.getCallInfo().getCallId();
    Log.i(TAG,  "isVideo: " + isVideo + "callId: " + callId);

    Session callSession = getCallSessionByCallID(callId);
    if (callSession == null)
    {
        return;
    }
    CallInfo callInfo = getCallInfo(call);//audio --> video success
    Log.i(TAG, "Upgrade To Video Call");
    VideoMgr.getInstance().setVideoOrient(callId, CallConstant.FRONT_CAMERA);

    callSession.setCallStatus(CallConstant.CallStatus.VIDEO_CALLING);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.OPEN_VIDEO, callInfo);
}

void onEvtRefreshViewInd(TsdkCall call, TsdkVideoViewRefresh refreshInfo); 

//Java code
public void onEvtRefreshViewInd(TsdkCall call, TsdkVideoViewRefresh refreshInfo){
    Log.i(TAG, "refreshLocalView");
    int mediaType = refreshInfo.getViewType();
    int eventType = refreshInfo.getEvent();
    int callId = call.getCallInfo().getCallId();

    switch (mediaType)
    {
        case 1: //local video preview
        case 2: //general video
            if (eventType == 1) //add local view
            {
                //VideoDeviceManager.getInstance().refreshLocalVideo(true, callId);
                mCallNotification.onCallEventNotify(CallConstant.CallEvent.ADD_LOCAL_VIEW, callId);
            }
            else //remove local view
            {
                //VideoDeviceManager.getInstance().refreshLocalVideo(false, callId);
                mCallNotification.onCallEventNotify(CallConstant.CallEvent.DEL_LOCAL_VIEW, callId);
            }
            break;

        case 3: //auxiliary data
            break;

        default:
            break;
    }

}

void onEvtCallRouteChange(TsdkCall call, long route); 

//Java code
None

void onEvtPlayMediaEnd(long handle); 

//Java code
None

void onEvtSessionModified(TsdkCall call, TsdkSessionModified sessionInfo); 

//Java code
None

void onEvtSessionCodec(TsdkCall call, TsdkSessionCodec codecInfo); 

//Java code
None

void onEvtHoldSuccess(TsdkCall call); 

//Java code
public void onEvtHoldSuccess(TsdkCall call){
    Log.i(TAG, "handleHoldSuccess");
    CallInfo callInfo = getCallInfo(call);
    Session callSession = getCallSessionByCallID(callInfo.getCallID());
    if (callSession.isVideoHold())
    {
        mCallNotification.onCallEventNotify(CallConstant.CallEvent.VIDEO_HOLD_SUCCESS, callInfo);
    }
    else
    {
        mCallNotification.onCallEventNotify(CallConstant.CallEvent.AUDIO_HOLD_SUCCESS, callInfo);
    }
}

void onEvtHoldFailed(TsdkCall call); 

//Java code
public void onEvtHoldFailed(TsdkCall call){
    Log.i(TAG, "handleHoldFailed");
    CallInfo callInfo = getCallInfo(call);
    Session callSession = getCallSessionByCallID(callInfo.getCallID());
    if (callSession.isVideoHold())
    {
        callSession.setVideoHold(false);
        //保持失敗，只直接通知UI失敗，不自動(dòng)恢復(fù)視頻
        mCallNotification.onCallEventNotify(CallConstant.CallEvent.VIDEO_HOLD_FAILED, callInfo);
    }
    else
    {
        mCallNotification.onCallEventNotify(CallConstant.CallEvent.AUDIO_HOLD_FAILED, callInfo);
    }
}

void onEvtUnholdSuccess(TsdkCall call); 

//Java code
public void onEvtUnholdSuccess(TsdkCall call){
    Log.i(TAG, "handleUnholdSuccess");
    int callId = call.getCallInfo().getCallId();
    Session callSession = getCallSessionByCallID(callId);
    if (callSession == null)
    {
        Log.e(TAG, "call session obj is null");
        return;
    }

    //如果此保持發(fā)起時(shí)是“視頻保持”，則再在“保持恢復(fù)”后，請(qǐng)求遠(yuǎn)端“增加視頻”
    if (callSession.isVideoHold())
    {
        addVideo(callId);
        callSession.setVideoHold(false);
    }

    //調(diào)試音頻
    CallInfo callInfo = getCallInfo(call);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.UN_HOLD_SUCCESS, callInfo);
}

void onEvtUnholdFailed(TsdkCall call); 

//Java code
public void onEvtUnholdFailed(TsdkCall call){
    Log.i(TAG, "handleUnholdFailed");

    CallInfo callInfo = getCallInfo(call);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.UN_HOLD_FAILED, callInfo);
}

void onEvtEndcallFailed(TsdkCall call, TsdkCommonResult result); 

//Java code
None

void onEvtDivertFailed(TsdkCall call); 

//Java code
public void onEvtDivertFailed(TsdkCall call){
    Log.i(TAG, "handleDivertFailed");

    CallInfo callInfo = getCallInfo(call);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.DIVERT_FAILED, callInfo);
}

void onEvtBldTransferSuccess(TsdkCall call); 

//Java code
public void onEvtBldTransferSuccess(TsdkCall call){
    Log.i(TAG, "handleBldTransferSuccess");

    CallInfo callInfo = getCallInfo(call);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.BLD_TRANSFER_SUCCESS, callInfo);
}

void onEvtBldTransferFailed(TsdkCall call); 

//Java code
public void onEvtBldTransferFailed(TsdkCall call){
    Log.i(TAG, "handleBldTransferFailed");

    CallInfo callInfo = getCallInfo(call);
    mCallNotification.onCallEventNotify(CallConstant.CallEvent.BLD_TRANSFER_FAILED, callInfo);
}

void onEvtStatisticInfo(TsdkCall call, long signalStrength, TsdkCallStatisticInfo statisticInfo); 

//Java code
public void onEvtStatisticInfo(TsdkCall call, long signalStrength, TsdkCallStatisticInfo statisticInfo) {
	CallMgr.getInstance().handleUpDateCallStatisticInfo(signalStrength, statisticInfo);
}

void onEvtBookConfResult(TsdkCommonResult result, TsdkConfBaseInfo confBaseInfo); 

//Java code
public void handleBookConfResult(TsdkCommonResult result, TsdkConfBaseInfo confBaseInfo){
    Log.i(TAG, "onBookReservedConfResult");
    if ((result == null) || (confBaseInfo == null))
    {
        Log.e(TAG, "book conference is failed, unknown error.");
        mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.BOOK_CONF_FAILED, -1);
        return;
    }
    if (result.getResult() != TupConfParam.CONF_RESULT.TUP_SUCCESS)
    {
        Log.e(TAG, "book conference is failed, return ->" + result.getResult());
        mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.BOOK_CONF_FAILED, result.getResult());
        return;
    }
    Log.i(TAG, "book conference is success.");
    mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.BOOK_CONF_SUCCESS, result.getResult());
}

void onEvtQueryConfListResult(TsdkCommonResult result, TsdkConfListInfo confList); 

//Java code
public void handleQueryConfListResult(TsdkCommonResult result, TsdkConfListInfo confList){
    Log.i(TAG, "onGetConfListResult");
    if (result == null)
    {
        Log.e(TAG, "get conference list is failed, unknown error.");
        mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.QUERY_CONF_LIST_FAILED, -1);
        return;
    }
    else if (result.getResult() != 0)
    {
        Log.e(TAG, "get conference list is failed, return ->" + result.getReasonDescription());
        mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.QUERY_CONF_LIST_FAILED, result.getResult());
        return;
    }
    List<ConfBaseInfo> confBaseInfoList = new ArrayList<>();
    List<TsdkConfBaseInfo> tsdkConfBaseInfos = confList.getConfInfoList();
    if (null != tsdkConfBaseInfos) {
        for (TsdkConfBaseInfo confInfo : tsdkConfBaseInfos) {
            ConfBaseInfo confBaseInfo = new ConfBaseInfo();
            confBaseInfo.setSize(confInfo.getSize());
            confBaseInfo.setConfID(confInfo.getConfId());
            confBaseInfo.setSubject(confInfo.getSubject());
            confBaseInfo.setAccessNumber(confInfo.getAccessNumber());
            confBaseInfo.setChairmanPwd(confInfo.getChairmanPwd());
            confBaseInfo.setGuestPwd(confInfo.getGuestPwd());
            confBaseInfo.setSchedulerNumber(confInfo.getScheduserAccount());
            confBaseInfo.setSchedulerName(confInfo.getScheduserName());
            confBaseInfo.setStartTime(confInfo.getStartTime());
            confBaseInfo.setEndTime(confInfo.getEndTime());
            confBaseInfo.setMediaType(ConfConvertUtil.convertConfMediaType(confInfo.getConfMediaType()));
            confBaseInfo.setConfState(ConfConvertUtil.convertConfctrlConfState(confInfo.getConfState()));
            confBaseInfoList.add(confBaseInfo);
        }
    }
    mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.QUERY_CONF_LIST_SUCCESS, confBaseInfoList);
}

void onEvtQueryConfDetailResult(TsdkCommonResult result, TsdkConfDetailInfo confDetailInfo);

//Java code
public void handleQueryConfDetailResult(TsdkCommonResult result, TsdkConfDetailInfo tsdkConfDetailInfo){
    Log.i(TAG, "onGetConfInfoResult");
    if ((result == null) || (tsdkConfDetailInfo == null))
    {
        Log.e(TAG, "get conference detail is failed, unknown error.");
        mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.QUERY_CONF_DETAIL_FAILED, -1);
        return;
    }
    if (result.getResult() != TupConfParam.CONF_RESULT.TUP_SUCCESS)
    {
        Log.e(TAG, "get conference detail is failed, return ->" + result.getResult());
        mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.QUERY_CONF_DETAIL_FAILED, result.getResult());
        return;
    }
    ConfDetailInfo confDetailInfo = new ConfDetailInfo();
    confDetailInfo.setSize(tsdkConfDetailInfo.getConfInfo().getSize());
    confDetailInfo.setConfID(tsdkConfDetailInfo.getConfInfo().getConfId());
    confDetailInfo.setSubject(tsdkConfDetailInfo.getConfInfo().getSubject());
    confDetailInfo.setAccessNumber(tsdkConfDetailInfo.getConfInfo().getAccessNumber());
    confDetailInfo.setChairmanPwd(tsdkConfDetailInfo.getConfInfo().getChairmanPwd());
    confDetailInfo.setGuestPwd(tsdkConfDetailInfo.getConfInfo().getGuestPwd());
    confDetailInfo.setSchedulerNumber(tsdkConfDetailInfo.getConfInfo().getScheduserAccount());
    confDetailInfo.setSchedulerName(tsdkConfDetailInfo.getConfInfo().getScheduserName());
    confDetailInfo.setStartTime(tsdkConfDetailInfo.getConfInfo().getStartTime());
    confDetailInfo.setEndTime(tsdkConfDetailInfo.getConfInfo().getEndTime());
    confDetailInfo.setMediaType(ConfConvertUtil.convertConfMediaType(tsdkConfDetailInfo.getConfInfo().getConfMediaType()));
    confDetailInfo.setConfState(ConfConvertUtil.convertConfctrlConfState(tsdkConfDetailInfo.getConfInfo().getConfState()));
    List<Member> memberList = ConfConvertUtil.convertAttendeeInfoList(tsdkConfDetailInfo.getAttendeeList());
    confDetailInfo.setMemberList(memberList);
    mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.QUERY_CONF_DETAIL_SUCCESS, confDetailInfo);
}

 void onEvtJoinConfResult(TsdkConference conference, TsdkCommonResult result, TsdkJoinConfIndInfo info);

//Java code
public void handleJoinConfResult(TsdkConference tsdkConference, TsdkCommonResult commonResult, TsdkJoinConfIndInfo tsdkJoinConfIndInfo
    Log.i(TAG, "handleJoinConfResult");
    if ((tsdkConference == null) || (commonResult == null)) {
        return;
    }
    int result = commonResult.getResult();
    if (result == 0)
    {
        this.currentConference = tsdkConference;
        this.memberList = null;
        this.self = null;
        TsdkCall tsdkCall = tsdkConference.getCall();
        if (null != tsdkCall) {
            Session newSession = CallMgr.getInstance().getCallSessionByCallID(tsdkCall.getCallInfo().getCallId());
            if (null == newSession) {
                newSession = new Session(tsdkCall);
                CallMgr.getInstance().putCallSessionToMap(newSession);
            }
            if (tsdkCall.getCallInfo().getIsVideoCall() == 1) {
                VideoMgr.getInstance().initVideoWindow(tsdkCall.getCallInfo().getCallId());
            }
        }
        mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.JOIN_CONF_SUCCESS, tsdkConference.getHandle() + "");
    }
    else
    {
        mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.JOIN_CONF_FAILED, result);
    }
}

void onEvtGetDataconfParamResult(TsdkConference conference, TsdkCommonResult result); 

//Java code
public void  handleGetDataConfParamsResult(TsdkConference tsdkConference, TsdkCommonResult commonResult){
    Log.i(TAG, "handleJoinConfResult");
    if ((tsdkConference == null) || (commonResult == null)) {
        return;
    }
    int result = commonResult.getResult();
    mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.GET_DATA_CONF_PARAM_RESULT, result);
}

void onEvtConfctrlOperationResult(TsdkConference conference, TsdkConfOperationResult result);

//Java code
public void handleConfctrlOperationResult(TsdkConference conference, TsdkConfOperationResult result)
{
    Log.i(TAG, "handleConfctrlOperationResult");
    int ret = result.getReasonCode();
    if (null == conference || null == result)
    {
        return;
    }
    if (ret != 0)
    {
        Log.e(TAG, "conf ctrl operation failed: " + result.getDescription());
        return;
    }
    int confOperationType = result.getOperationType();
    switch (confOperationType)
    {
        //閉音會(huì)場(chǎng)
        case 2:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.MUTE_CONF_RESULT, ret);
            break;
        //取消閉音
        case 3:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.UN_MUTE_CONF_RESULT, ret);
            break;
        //鎖定會(huì)議
        case 4:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.LOCK_CONF_RESULT, ret);
            break;
        //取消鎖定
        case 5:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.UN_LOCK_CONF_RESULT, ret);
            break;
        //添加與會(huì)者
        case 6:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.ADD_ATTENDEE_RESULT, ret);
            break;
        //刪除與會(huì)者
        case 7:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.DEL_ATTENDEE_RESULT, ret);
            break;
        //閉音與會(huì)者
        case 10:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.MUTE_ATTENDEE_RESULT, ret);
            break;
        //取消閉音與會(huì)者
        case 11:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.UN_MUTE_ATTENDEE_RESULT, ret);
            break;
        //設(shè)置舉手
        case 12:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.HAND_UP_RESULT, ret);
            break;
        //取消設(shè)置舉手
        case 13:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.CANCEL_HAND_UP_RESULT, ret);
            break;
        //申請(qǐng)主席權(quán)限
        case 18:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.REQUEST_CHAIRMAN_RESULT, ret);
            break;
        //釋放主席權(quán)限
        case 19:
            mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.RELEASE_CHAIRMAN_RESULT, ret);
            break;
        default:
            break;
    }
}

void onEvtInfoAndStatusUpdate(TsdkConference conference); 

//Java code
public void handleInfoAndStatusUpdate(TsdkConference conference){
    Log.i(TAG, "onConfStatusUpdateInd");
    if ((currentConference == null) || (conference == null))
    {
        return;
    }
    if (currentConference.getHandle() != conference.getHandle())
    {
        return;
    }
    String handle = conference.getHandle()+"";
    this.updateConfInfo(conference);
    mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.STATE_UPDATE, handle);
}

void onEvtSpeakerInd(TsdkConference conference, TsdkConfSpeakerInfo speakerList); 

//Java code
public void handleSpeakerInd(TsdkConfSpeakerInfo speakerList) {
	Log.i(TAG, "onEvtSpeakerInd");

	if (null == speakerList)
	{
		return;
	}

	if (speakerList.getSpeakerNum() > 0)
	{
		this.updateSpeaker(speakerList);
	}

	mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.SPEAKER_LIST_IND, speakerList.getSpeakerNum());
}

void onEvtRequestConfRightFailed(TsdkConference conference, TsdkCommonResult result); 

//Java code
None

void onEvtConfIncomingInd(TsdkConference conference);

//Java code
public void handleConfIncomingInd(TsdkConference conference){
    if (null == conference)
    {
        return;
    }
    currentConference = conference;
    TsdkCall tsdkCall = conference.getCall();
    if (null != tsdkCall) {
        Session newSession = CallMgr.getInstance().getCallSessionByCallID(tsdkCall.getCallInfo().getCallId());
        if (null == newSession) {
            newSession = new Session(tsdkCall);
            CallMgr.getInstance().putCallSessionToMap(newSession);
        }
    }
    mConfNotification.onConfEventNotify(ConfConstant.CONF_EVENT.CONF_INCOMING_TO_CALL_INCOMING, conference);
}