android安卓使用socketIO实现聊天室功能

2023-10-30

安卓使用socketIo实现聊天室Demo1:安卓androidSocketIo使用方式socketIo-Android文档类资源-CSDN下载安卓使用socketio,和服务器进行通信,实现聊天室功能,可以正常进入退出聊天室,可以发送消息更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/jifenglie/81102204

安卓使用socketio实现聊天室Demo2:

安卓androidSocketIo使用方式socketIo-Android文档类资源-CSDN下载安卓使用socketio,和服务器进行通信,实现聊天室功能,可以正常进入退出聊天室,可以发送消息更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/jifenglie/81102204 自己定义的聊天页面:

 引入:

   compile('io.socket:socket.io-client:1.0.0') {
       exclude group: 'org.json', module: 'json'
   }

初始化

try {
            mSocket = IO.socket(Config.WEBSOCKET_URL + userId);//注册
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }

注册监听方法,被动接收服务器消息,接收方法调用的回掉信息

mSocket.on(Socket.EVENT_CONNECT, onConnect);//注册监听方法
        mSocket.on(Socket.EVENT_DISCONNECT, onDisconnect);
        mSocket.on(Socket.EVENT_CONNECT_ERROR, onConnectError);
        mSocket.on(Socket.EVENT_CONNECT_TIMEOUT, onConnectError);
 
 
        mSocket.on(Constants.NEW_JOIN_ROOM, new Emitter.Listener() {//注册监听方法
            @Override
            public void call(final Object... args) {
                Log.e("NEW_JOIN_ROOM", "加入直播间");
                parseData(args);
            }
        });
        mSocket.on(Constants.NEW_GROUP, new Emitter.Listener() {//注册监听方法
            @Override
            public void call(final Object... args) {
                Log.e("NEW_GROUP", "新消息...");
                parseData(args);
            }
        });
 
        mSocket.on(Constants.BROADCAST, new Emitter.Listener() {
            @Override
            public void call(final Object... args) {
                Log.e("BROADCAST", "BROADCAST");
                parseData(args);
            }
        });
 
        mSocket.on(Constants.EXIT_ROOM, new Emitter.Listener() {
            @Override
            public void call(final Object... args) {
                Log.e("EXIT_ROOM", "退出直播间");
                parseData(args);
            }
        });
 
        mSocket.connect();//链接



private Emitter.Listener onConnect = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Log.e("onConnect", "连接成功...");
        }
    };
 
    private Emitter.Listener onDisconnect = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Log.e("error", args.toString());
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Log.i(TAG, "diconnected");
                    Toast.makeText(getApplicationContext(), "退出直播间", Toast.LENGTH_LONG).show();
                }
            });
        }
    };
 
    private Emitter.Listener onConnectError = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Log.e("error", args.toString());
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Log.e(TAG, "Error connecting");
                    Toast.makeText(getApplicationContext(),
                            R.string.error_connect, Toast.LENGTH_LONG).show();
                }
            });
        }
    };

主动发送消息 

        RequestBean bean = new RequestBean();
        bean.setGroupId(roomId + "");
        bean.setUserId(userId + "");
        mSocket.emit(Constants.NEW_JOIN_ROOM, new Gson().toJson(bean));

//Constants.NEW_JOIN_ROOM  是方法名 和服务器方法名一致

在activity中正常使用:

package com.leying.livestreaming.ui.activtiy;

import android.Manifest;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.os.Build;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import androidx.core.app.ActivityCompat;
import androidx.databinding.DataBindingUtil;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.leying.livestreaming.Config;
import com.leying.livestreaming.R;
import com.leying.livestreaming.bean.ChatMessage;
import com.leying.livestreaming.bean.RequestBean;
import com.leying.livestreaming.bean.ResultMsgBean;
import com.leying.livestreaming.bean.SendMsgBean;
import com.leying.livestreaming.common.base.BaseActivity;
import com.leying.livestreaming.common.base.ResultBean;
import com.leying.livestreaming.common.basebean.ItemBean;
import com.leying.livestreaming.common.utils.SPUtils;
import com.leying.livestreaming.common.utils.ToastUtils;
import com.leying.livestreaming.databinding.LiveplayActivityLivePlayBinding;
import com.leying.livestreaming.net.ApiService;
import com.leying.livestreaming.ui.adapter.ItemDemoAdapter;
import com.leying.livestreaming.ui.viewModel.LivePlayViewModel;
import com.leying.livestreaming.utils.Constants;
import com.tencent.live2.V2TXLiveDef;
import com.tencent.live2.V2TXLivePlayer;
import com.tencent.live2.V2TXLivePlayerObserver;
import com.tencent.live2.impl.V2TXLivePlayerImpl;
import com.tencent.rtmp.ui.TXCloudVideoView;

import java.lang.reflect.Type;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;

import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import io.socket.client.IO;
import io.socket.client.Socket;
import io.socket.emitter.Emitter;

import static com.leying.livestreaming.common.basebean.ItemBean.DEFAULT_MSG;
import static com.leying.livestreaming.common.basebean.ItemBean.ME_SEND_MSG;
import static com.leying.livestreaming.common.basebean.ItemBean.PERSON_SEND_MSG;


/**
 * MLVB 直播拉流详情页
 * <p>
 * 包含如下简单功能:
 * <p>
 * 详见接入文档{https://cloud.tencent.com/document/product/454/56598}
 * <p>
 * <p>
 * Playback View
 * <p>
 * Features:
 * <p>
 * For more information, please see the integration document {https://cloud.tencent.com/document/product/454/56598}.
 */
public class LivePlayActivity2 extends BaseActivity<LiveplayActivityLivePlayBinding> implements View.OnClickListener {
    private static final String TAG = "LivePlayActivity";
    protected static final int REQ_PERMISSION_CODE = 0x1000;
    protected int mGrantedCount = 0;
    private Socket mSocket;


    private TXCloudVideoView mPlayRenderView;
    private V2TXLivePlayer mLivePlayer;
    private boolean mPlayFlag = false;
    private Button mButtonMute;
    private TextView mTextTitle;

    private ItemDemoAdapter itemDemoAdapter;
    private RecyclerView recyclerView;

    private List<ChatMessage> recivceMsgs = new ArrayList<>();

    private LivePlayViewModel viewModel;
    //    String playURL = "rtmp://live.lymatrix.com/live/5?txSecret=c83fa857eecaca45d0f6b851415c11cf&txTime=61E23988";
    String playURL = "";

    private boolean isHeadShow = true;
    private boolean isFullScreen = false;


    private String mStreamId;
    private int mStreamType = 0;    //0: RTC; 1:RTMP; 2:WEBRTC
    private String roomId = "";    //0: RTC; 1:RTMP; 2:WEBRTC
    private String userId = "";
    private boolean mPlayAudioFlag = true;


    @Override
    protected int getLayoutId() {
        return R.layout.liveplay_activity_live_play;
    }


    @Override
    protected void initView() {
        super.initView();

        setStatusBarColor(R.color.common_bg_color);
        roomId = getIntent().getStringExtra(Constants.ROOM_ID);
        userId = SPUtils.getSharedStringData(SPUtils.USER_ID);

        Log.e("roomId---userId", roomId + "---" + userId);

        try {
            mSocket = IO.socket(Config.WEBSOCKET_URL + userId);//注册
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }


        registMethod();
        initPlayView();
    }


    List<ItemBean> chatInfoDatas = new ArrayList<>();


    private void initPlayView() {
        dataBinding = DataBindingUtil.setContentView(this, getLayoutId());
        int orientation = getResources().getConfiguration().orientation;
        if (orientation == Configuration.ORIENTATION_PORTRAIT) {

            if (checkPermission()) {
                initIntentData();
                initView2();
                getPalyUrl();
            }


            recyclerView = dataBinding.recyclerView;
            recyclerView.setLayoutManager(new LinearLayoutManager(this));
            itemDemoAdapter = new ItemDemoAdapter(this, new ArrayList<ItemBean>());
            recyclerView.setAdapter(itemDemoAdapter);

            viewModel = new LivePlayViewModel(this, recivceMsgs);
            viewModel.initData(itemDemoAdapter);

            if (chatInfoDatas.size() > 0) {
                itemDemoAdapter.addDatas(chatInfoDatas);
            }
//            chatInfoDatas = itemDemoAdapter.getDatas();

            dataBinding.buttonSend.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    String msg = dataBinding.msgET.getText().toString().trim();
                    if ("".equals(msg)) {
                        return;
                    }
                    SendMsgBean bean = new SendMsgBean();
                    bean.setMessage(msg);
                    bean.setFromUid(userId + "");
                    bean.setGroupId(roomId + "");
                    mSocket.emit(Constants.NEW_GROUP, new Gson().toJson(bean));//发送新消息
                    dataBinding.msgET.setText("");
                    hintKeyBoard();
                }
            });

            dataBinding.playTxCloudView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (isHeadShow) {
                        hidenHeadView();
                    } else {
                        showHeadView();
                    }
                }
            });
            dataBinding.fullScreen.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
                }
            });

            dataBinding.ivBack.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    finish();
                }
            });

            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
        } else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
            chatInfoDatas = itemDemoAdapter.getDatas();

            getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
            if (checkPermission()) {
                initIntentData();
                initView2();
                getPalyUrl();
            }

            dataBinding.playTxCloudView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (isHeadShow) {
                        hidenHeadView();
                    } else {
                        showHeadView();
                    }
                }
            });

            dataBinding.halfScreen.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
                }
            });

            dataBinding.ivBack.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
                }
            });
        }
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);

        initPlayView();
    }

    @Override
    public void onBackPressed() {
        if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            return;
        }
        super.onBackPressed();
    }

    public void hintKeyBoard() {
        //拿到InputMethodManager
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        //如果window上view获取焦点 && view不为空
        if (imm.isActive() && getCurrentFocus() != null) {
            //拿到view的token 不为空
            if (getCurrentFocus().getWindowToken() != null) {
                //表示软键盘窗口总是隐藏,除非开始时以SHOW_FORCED显示。
                imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
            }
        }
    }

    private void registMethod() {
        mSocket.on(Socket.EVENT_CONNECT, onConnect);//注册监听方法
        mSocket.on(Socket.EVENT_DISCONNECT, onDisconnect);
        mSocket.on(Socket.EVENT_CONNECT_ERROR, onConnectError);
        mSocket.on(Socket.EVENT_CONNECT_TIMEOUT, onConnectError);


        mSocket.on(Constants.NEW_JOIN_ROOM, new Emitter.Listener() {//注册监听方法
            @Override
            public void call(final Object... args) {
                Log.e("NEW_JOIN_ROOM", "加入直播间");
                parseData(args);
            }
        });
        mSocket.on(Constants.NEW_GROUP, new Emitter.Listener() {//注册监听方法
            @Override
            public void call(final Object... args) {
                Log.e("NEW_GROUP", "新消息...");
                parseData(args);
            }
        });

        mSocket.on(Constants.BROADCAST, new Emitter.Listener() {
            @Override
            public void call(final Object... args) {
                Log.e("BROADCAST", "BROADCAST");
                parseData(args);
            }
        });

        mSocket.on(Constants.EXIT_ROOM, new Emitter.Listener() {
            @Override
            public void call(final Object... args) {
                Log.e("EXIT_ROOM", "退出直播间");
                parseData(args);
            }
        });

        mSocket.connect();


        RequestBean bean = new RequestBean();
        bean.setGroupId(roomId + "");
        bean.setUserId(userId + "");
        mSocket.emit(Constants.NEW_JOIN_ROOM, new Gson().toJson(bean));
    }


    private void parseData(final Object... args) {
        ChatMessage el = null;
        try {
            if (args.length > 0) {
                String jsonel = new Gson().toJson(args[0]);
                Type typel = new TypeToken<ResultMsgBean>() {
                }.getType();
                ResultMsgBean bean = new Gson().fromJson(jsonel, typel);
                el = bean.getNameValuePairs();
            }
        } catch (Exception e) {
            Log.e("NEW_JOIN_ROOM", "返回值解析错误" + e.getMessage());
        }
        if (el != null) {
            dealRecivceMsg(el);
        }
    }


    private void dealRecivceMsg(ChatMessage el) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                if (el.getTypes() == 6) {//上线
                    itemDemoAdapter.add(new ItemBean.Builder().key("进入直播间").value(el.getNickName() + "进入直播间").viewType(DEFAULT_MSG).build());
                } else if (el.getTypes() == 7) {//下线
                    itemDemoAdapter.add(new ItemBean.Builder().key("退出直播间").value(el.getNickName() + "退出直播间").viewType(DEFAULT_MSG).build());
                } else if (el.getTypes() == 0) {//新消息
                    if (el.getUserId().equals(userId)) {//本人发消息
                        itemDemoAdapter.add(new ItemBean.Builder().key("新消息").value4(el.getUrl()).value(el.getNickName()).value2("").value3(el.getChatContent()).value4(el.getUrl()).viewType(ME_SEND_MSG).isLabel(false).build());
                    } else {//其余人员发送消息  roles0学生,1老师,2班主任
                        String type0 = "";
                        boolean show = false;
                        boolean isBanZhuRen=false;
                        if (el.getRoles() == 0) {
                            show = false;
                        } else if (el.getRoles() == 1) {
                            show = true;
                            type0 = "主讲";
                            isBanZhuRen=false;
                        } else if (el.getRoles() == 2) {
                            show = true;
                            type0 = "班主任";
                            isBanZhuRen=true;
                        }
                        itemDemoAdapter.add(new ItemBean.Builder().key("新消息").value4(el.getUrl()).value(el.getNickName()).value2(type0).value3(el.getChatContent()).value4(el.getUrl()).viewType(PERSON_SEND_MSG).isLabel(show).enable(isBanZhuRen).build());
                    }
                } else {

                }
                dataBinding.recyclerView.scrollToPosition(itemDemoAdapter.getDatas().size() - 1);
            }
        });
    }


    private void initIntentData() {
        mStreamId = getIntent().getStringExtra("STREAM_ID");
        mStreamType = getIntent().getIntExtra("STREAM_TYPE", 0);
    }

    protected void initView2() {
        mPlayRenderView = findViewById(R.id.play_tx_cloud_view);
        mButtonMute = findViewById(R.id.btn_mute);
        mTextTitle = findViewById(R.id.tv_title);
        mButtonMute.setOnClickListener(this);
//        findViewById(R.id.iv_back).setOnClickListener(this);
        if (!TextUtils.isEmpty(mStreamId)) {
            mTextTitle.setText(mStreamId);
        }
    }

    @SuppressLint("CheckResult")
    private void getPalyUrl() {
        ApiService.service
                .getPalyUrl(roomId, 1)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResultBean<String>>() {
                    @Override
                    public void accept(ResultBean<String> result) throws Exception {
                        if (result.isSuccess() || result.getCode() == 200) {
                            playURL = result.getData();

                            startPlay();
                        } else {
//                            viewDataBinding.loadingView.setType(LoadingView.WEIGHT_EMPTY);
                            ToastUtils.showShort(LivePlayActivity2.this, result.getMsg());
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
//                        viewDataBinding.loadingView.setType(LoadingView.WEIGHT_EMPTY);
                        ToastUtils.showShort(LivePlayActivity2.this, "网络访问失败", throwable);
                    }
                });
    }


    private void startPlay() {
//        String playURL = URLUtils.generatePlayUrl(mStreamId, userId, mStreamType);

        mLivePlayer = new V2TXLivePlayerImpl(LivePlayActivity2.this);
        mLivePlayer.setRenderFillMode(V2TXLiveDef.V2TXLiveFillMode.V2TXLiveFillModeFit);
//        mLivePlayer.setRenderRotation(V2TXLiveDef.V2TXLiveRotation.V2TXLiveRotation270);
        mLivePlayer.setRenderView(mPlayRenderView);
        mLivePlayer.setObserver(new V2TXLivePlayerObserver() {

            @Override
            public void onError(V2TXLivePlayer player, int code, String msg, Bundle extraInfo) {
                Log.d(TAG, "[Player] onError: player-" + player + " code-" + code + " msg-" + msg + " info-" + extraInfo);
            }

//            @Override
//            public void onVideoLoading(V2TXLivePlayer player, Bundle extraInfo) {
//                Log.i(TAG, "[Player] onVideoLoading: player-" + player + ", extraInfo-" + extraInfo);
//            }

//            @Override
//            public void onVideoPlaying(V2TXLivePlayer player, boolean firstPlay, Bundle extraInfo) {
//                Log.i(TAG, "[Player] onVideoPlaying: player-"
//                        + player + " firstPlay-" + firstPlay + " info-" + extraInfo);
//            }

//            @Override
//            public void onVideoResolutionChanged(V2TXLivePlayer player, int width, int height) {
//                Log.i(TAG, "[Player] onVideoResolutionChanged: player-"
//                        + player + " width-" + width + " height-" + height);
//            }

            @Override
            public void onWarning(V2TXLivePlayer v2TXLivePlayer, int i, String s, Bundle bundle) {
                Log.d(TAG, "[Player] Override: player-" + v2TXLivePlayer + ", i-" + i + ", s-" + s);
            }

            @Override
            public void onRenderVideoFrame(V2TXLivePlayer player, V2TXLiveDef.V2TXLiveVideoFrame v2TXLiveVideoFrame) {
                super.onRenderVideoFrame(player, v2TXLiveVideoFrame);
                Log.d(TAG, "[Player] onRenderVideoFrame: player-" + player + ", v2TXLiveVideoFrame-" + v2TXLiveVideoFrame);
            }
        });

        int result = mLivePlayer.startPlay(playURL);
        if (result == 0) {
            mPlayFlag = true;
        }
        Log.d(TAG, "startPlay : " + result);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注销监听方法
        mSocket.emit(Constants.EXIT_ROOM, roomId);
        mSocket.disconnect();
        mSocket.off(Socket.EVENT_CONNECT, onConnect);
        mSocket.off(Socket.EVENT_DISCONNECT, onDisconnect);
        mSocket.off(Socket.EVENT_CONNECT_ERROR, onConnectError);
        mSocket.off(Socket.EVENT_CONNECT_TIMEOUT, onConnectError);
        mSocket.off(Constants.NEW_JOIN_ROOM);
        mSocket.off(Constants.NEW_GROUP);
        mSocket.off(Constants.BROADCAST);
        mSocket.off(Constants.EXIT_ROOM);


        if (mLivePlayer != null) {
            if (mPlayFlag) {
                mLivePlayer.stopPlay();
            }
            mLivePlayer = null;
        }
    }

    @Override
    public void onClick(View view) {
        int id = view.getId();
        if (id == R.id.iv_back) {
            finish();
        } else if (id == R.id.btn_mute) {
            mute();
        }
    }

    private void mute() {
        if (mLivePlayer != null && mLivePlayer.isPlaying() == 1) {
            if (mPlayAudioFlag) {
                mLivePlayer.pauseAudio();
                mPlayAudioFlag = false;
                mButtonMute.setText("取消静音");
            } else {
                mLivePlayer.resumeAudio();
                mPlayAudioFlag = true;
                mButtonMute.setText("静音");
            }
        }
    }


    private Emitter.Listener onConnect = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Log.e("onConnect", "连接成功...");
        }
    };

    private Emitter.Listener onDisconnect = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Log.e("error", args.toString());
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Log.i(TAG, "diconnected");
                    Toast.makeText(getApplicationContext(), "退出直播间", Toast.LENGTH_LONG).show();
                }
            });
        }
    };

    private Emitter.Listener onConnectError = new Emitter.Listener() {
        @Override
        public void call(Object... args) {
            Log.e("error", args.toString());
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Log.e(TAG, "Error connecting");
                    Toast.makeText(getApplicationContext(),
                            R.string.error_connect, Toast.LENGTH_LONG).show();
                }
            });
        }
    };




    protected boolean checkPermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            List<String> permissions = new ArrayList<>();
            if (PackageManager.PERMISSION_GRANTED != ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                permissions.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
            }
            if (PackageManager.PERMISSION_GRANTED != ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA)) {
                permissions.add(Manifest.permission.CAMERA);
            }
            if (PackageManager.PERMISSION_GRANTED != ActivityCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO)) {
                permissions.add(Manifest.permission.RECORD_AUDIO);
            }
            if (PackageManager.PERMISSION_GRANTED != ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE)) {
                permissions.add(Manifest.permission.READ_EXTERNAL_STORAGE);
            }
            if (permissions.size() != 0) {
                ActivityCompat.requestPermissions(LivePlayActivity2.this,
                        permissions.toArray(new String[0]),
                        REQ_PERMISSION_CODE);
                return false;
            }
        }
        return true;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case REQ_PERMISSION_CODE:
                for (int ret : grantResults) {
                    if (PackageManager.PERMISSION_GRANTED == ret) {
                        mGrantedCount++;
                    }
                }
                if (mGrantedCount == permissions.length) {
                    initView2();
                    startPlay();
                } else {
                    Toast.makeText(this, "用户没有允许需要的权限,启动失败", Toast.LENGTH_SHORT).show();
                }
                mGrantedCount = 0;
                break;
            default:
                break;
        }
    }


    public void setStatusBarColor(int colorId) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            Window window = getWindow();
            window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            window.setStatusBarColor(getResources().getColor(colorId));
        }
    }

    private void hidenHeadView() {
        dataBinding.head.setVisibility(View.GONE);
        dataBinding.bottom.setVisibility(View.GONE);
        isHeadShow = false;
    }

    private void showHeadView() {
        dataBinding.head.setVisibility(View.VISIBLE);
        dataBinding.bottom.setVisibility(View.VISIBLE);
        isHeadShow = true;
    }


}

Constants.java  :

package com.leying.livestreaming.utils;

public class Constants {

    public static final String ROOM_ID = "room_id";
    public static final String GROUP_ID = "group_id";


    /**
     * chatInfo  消息内容
     *
     * currentCount  这个是在线人数
     *
     * onMessage  发送消息的接口
     * disConnection  下线接口
     * connect  打开连接 上线
     *
     * 发送消息json里面 messageType  消息类型
     */

    public static final String CHATINFO = "chatInfo";
    public static final String CURRENTCOUNT = "currentCount";
    public static final String JOIN_ROOM = "join";
    public static final String ONMESSAGE = "onMessage";
    public static final String DISCONNECTION = "disConnection";
    public static final String CONNECT = "connect";
    public static final String EVENT_GET_DATA = "getdata";


    public static final String NEW_JOIN_ROOM = "newjoin";//加入直播间
    public static final String NEW_GROUP = "newgroup";//发送群消息
    public static final String BROADCAST = "broadcast";//广播消息
    public static final String EXIT_ROOM = "out";//退出直播间



//    public static final String ROOM_ID = "room_id";
    public static final String USER_ID = "user_id";

}

本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

android安卓使用socketIO实现聊天室功能 的相关文章

随机推荐

  • 值得收藏 Modbus RTU 协议详解

    值得收藏 Modbus RTU 协议详解 目录 值得收藏 Modbus RTU 协议详解 Modbus是什么 Modbus分类 Modbus通讯过程 Modbus RTU协议数据帧结构 功能码01 读线圈状态 功能码02 读离散量输入 功能
  • matlab 锐化降噪,matlab 图形锐化 滤波

    help imread help fspecial imfilt 帮助稳定中有较多的示例 fspecial 函数 功能 产生预定义滤波器 格式 H fspecial type H fspecial gaussian n sigma 高斯低通
  • 精密全波整流电路

    精密全波整流电路 单运放型 利用单运放构成的精密全波整流电路主要有两种 一种称之为 T 型 另一种称为 型 T 型精密全波整流电路的原理图如下 图1 T型精密全波整流电路 上面电路中 R1 R3 2 R2 当输入为正电压时 D1 导通D2截
  • HarmonyOS“一次开发,多端部署“优秀实践——玩机技巧,码上起航

    随着终端设备形态日益多样化 分布式技术逐渐打破单一硬件边界 一个应用或服务 可以在不同的硬件设备之间按需调用 互助共享 让用户享受无缝的全场景体验 作为应用开发者 广泛的设备类型也能为应用带来广大的潜在用户群体 一个应用要在多类设备上提供统
  • 【vscode安装以及c++环境配置】

    TOC vscode安装以及c 环境配置 VScode安装 安装vscode vscode官方下载 C 环境配置 安装c 环境 MinGw官方下载网址 下载版本选择 Architecture 如果电脑系统是64位就选x86 64 如果电脑系
  • 论文笔记之CentripetalNet

    提出使用向心偏移来对同一实例中的角点进行配对 此外又设计了一个 corner star deformable convolution network 十字星可变形卷积网络来适应corner特征 CVPR2020接收 论文地址 https a
  • 斐波那契数列的两种解题思路:递归VS迭代

    一 问题描述 要求输入一个整数n 请你输出斐波那契数列的第n项 二 算法分析 给出一系列斐波拉契数列 0 1 1 3 5 8 13 21 通过观察 很容易发现 1 n 0 1 f n f n 1 f n 2 n gt 1 三 算法设计 递归
  • 如何将数据从Activity返回到Fragment——onActivityResult

    一段时间没有写了 背景是这样的 MainActivity中启动Fragment Fragment启动OtherActivity 在OtherActivity中的数据需要返回到Fragment中 关于数据是怎么传输的 可以看这里 传送门 An
  • spring-boot-configuration-processor问题

    spring boot configuration processor问题 配置 application yml 时没有关联提示 配置好的属性提示 Cannot resolve configuration property xxxx 解决方
  • 【Mybatis】mysql插入记录后返回自增主键id的方法和注意事项

    插入记录后返回自增主键id mapping文件的insert标签中加入如下标签 指明主键名 keyProperty 执行方式 order 为新增完再返回执行 因为只有插入完成后获取的id才是最新的 返回值是Integer类型 也就是新增后返
  • Log4j2注入漏洞(CVE-2021-44228)万字深度剖析(四)—漏洞修复原理(2.15.0-RC1、2.15.0、2.16.0)

    系列文章 2 15 0之前版漏洞相关文章 Log4j2注入漏洞 CVE 2021 44228 万字深度剖析 一 开篇与基础知识 Log4j2注入漏洞 CVE 2021 44228 万字深度剖析 二 漏洞原理 Log4j2注入漏洞 CVE 2
  • 卡尔曼滤波学习笔记

    Kalman Filter 直观理解 1 描述 2 例子 适用范围 1 线性系统 2 噪声服从高斯分布 相关公式 1 原始公式 2 预测公式 3 更新公式 4 初值赋予 5 总结 应用例子 代码实现 公式理解 1 协方差矩阵的理解 1 1
  • 火柴棍等式

    描述 给你n根火柴棍 你可以拼出多少个形如 A B C 的等式 等式中的A B C是用火柴棍拼出的整数 若该数非零 则最高位不能是0 用火柴棍拼数字0 9的拼法如图所示 注意 1 加号与等号各自需要两根火柴棍 2 如果A B 则A B C与
  • qt---收音机多柱进度条实现

    1 底层用普通进度条 实现进度显示 2 放置label 背景图 放置柱状 垂直线 线条透明 3 设置为透明状态
  • Pinia 是否可以代替 Vuex ?

    文章目录 一 介绍 二 对比 Pinia 与 Vuex 对比 三 使用 1 安装 2 注册 3 创建单个 store 4 组件内引用 5 更新 store 数据的4种方式 1 直接修改特定的值 2 利用 patch 批量修改 3 利用 pa
  • git 修改远程仓库

    查看当前远程仓库 git remote v 修改远程仓库 git remote set url origin
  • wireshark抓包简易入门

    一 前言 由于分析需要一个MQ的问题 生产者发送MQ MQ basic ack 一直失败 所以想通过抓包工具看 下具体发生了什么 分析下原因 找到一篇非常nice的文章 故转载 收藏一波 原文地址 手把手教你用 wireshark 抓包 M
  • nginx配置文件基础配置汇总

    本篇主要是对nginx conf文件的的一些基本配置的汇总 方便日后使用 还有一些比较核心的 优化等配置会在另一篇写到 目录 配置文件结构 全局块 1 user指令 2 work process指令 3 其他指令 events块 http块
  • JVM 的发展历程及其基本概念 (一)

    一 JVM的基本介绍 1 随着Java7的正式发布 Java 虛拟机的设计者们通过JSR 292规范基本实现在Java虚拟机平台上运行非Java语言编写的程序 Java虚拟机根本不关心运行在其内部的程序到底是使用何种编程语言编写的 它只关心
  • android安卓使用socketIO实现聊天室功能

    安卓使用socketIo实现聊天室Demo1 安卓androidSocketIo使用方式socketIo Android文档类资源 CSDN下载安卓使用socketio 和服务器进行通信 实现聊天室功能 可以正常进入退出聊天室 可以发送消息