Android端WebSocket简单实现

最新推荐文章于 2024-08-10 21:46:38 发布
最新推荐文章于 2024-08-10 21:46:38 发布
阅读量1.5k 收藏 6
点赞数 1
文章标签： websocket android java
原文链接：https://blog.csdn.net/xch_yang/article/details/88888350
版权
该文详细介绍了如何在Android应用中集成Java-WebSocket库，创建WebSocket服务进行网络通信。服务包含了心跳检测机制，用于检测并维持连接状态。同时，为了保证服务在后台运行，使用了前台服务，并处理了不同Android版本下的兼容问题。此外，还提供了连接建立、消息收发、异常处理以及断开连接后的重连功能。
摘要由CSDN通过智能技术生成

1.导入Java-WebSocket依赖
implementation "org.java-websocket:Java-WebSocket:1.5.2"

2.AndroidManifest 添加权限和service 代码

 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <service android:name=".WebSocketService"></service>

3.服务包含心跳检测和连接操作

public class WebSocketService extends Service {
    private final static String TAG = "WebSocketService";
    public JWebSocketClient client;
    private JWebSocketClientBinder mBinder = new JWebSocketClientBinder();
    private final static int GRAY_SERVICE_ID = 1001;
    private static final long CLOSE_RECON_TIME = 15000;//连接断开或者连接错误立即重连
    private Notification notification;

    //用于Activity和service通讯
    public class JWebSocketClientBinder extends Binder {
        public WebSocketService getService() {
            return WebSocketService.this;
        }
    }

    //灰色保活
    public static class GrayInnerService extends Service {
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            startForeground(GRAY_SERVICE_ID, new Notification());
            stopForeground(true);
            stopSelf();
            return super.onStartCommand(intent, flags, startId);
        }
        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }
    }
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    @Override
    public void onCreate() {
        super.onCreate();

    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //初始化WebSocket
        initSocketClient();
        mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//开启心跳检测

        //设置service为前台服务，提高优先级
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) {
            //Android4.3以下 ，隐藏Notification上的图标
            startForeground(GRAY_SERVICE_ID, new Notification());
        } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
            //Android4.3 - Android8.0，隐藏Notification上的图标
            Intent innerIntent = new Intent(this, GrayInnerService.class);
            startService(innerIntent);
            startForeground(GRAY_SERVICE_ID, new Notification());
        } else {
            Intent nfIntent = new Intent(this, MainActivity.class);
            @SuppressLint("UnspecifiedImmutableFlag") Notification.Builder builder = new Notification.Builder(this.getApplicationContext())
                    .setContentIntent(PendingIntent.getActivity(this, 0, nfIntent, 0)) // 设置PendingIntent
                    .setSmallIcon(R.mipmap.ic_launcher) // 设置状态栏内的小图标
                    .setPriority(Notification.PRIORITY_MIN)
                    .setContentTitle(getResources().getString(R.string.app_name))
                    .setContentText("正在前台运行") // 设置上下文内容
                    .setWhen(System.currentTimeMillis()); // 设置该通知发生的时间

            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
                //修改安卓8.1以上系统报错
                NotificationChannel notificationChannel = new NotificationChannel("1", "CHANNEL_ONE_NAME",  NotificationManager.IMPORTANCE_MIN);
                notificationChannel.enableLights(false);//如果使用中的设备支持通知灯，则说明此通知通道是否应显示灯
                notificationChannel.setShowBadge(false);//是否显示角标
                notificationChannel.setLockscreenVisibility(Notification.VISIBILITY_SECRET);

                NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
                manager.createNotificationChannel(notificationChannel);
                builder.setChannelId("1");
            }
            // 获取构建好的Notification
            notification = builder.build();
            notification.defaults = Notification.DEFAULT_SOUND; //设置为默认的声音
            startForeground(GRAY_SERVICE_ID, notification);
        }
        return START_STICKY;
    }
    //这里是处理webscoket
    private void initSocketClient() {
       String url = "ws://端口号:ip地址";    //协议标识符是ws
        //ws://172.18.130.52:8089/webSocket/notice/117
        //协议标识符是ws
//（如果加密，则为wss），服务器网址就是 URL。  此处增加了请求头不需要的将map去掉即可
        URI uri = URI.create(url);
        HashMap<String, String> map = new HashMap<>();
   map.put("Authorization","eyJhbGciOiJIUzUxMiJ9.eyJsb2dpbl91c2VyX2tleSI6IjMyMjUwNTAzLTBlZmEtNDM5Mi1hYTQwLWRjNzk4YzE5M2Y3MSJ9.9mIXUU7UtdGm8ze6KhfSaeBPmeCelzd1RQn1B7akK-CF38MwVPwjqaknasjMiDI4WBUzX_2PRw2rQaYuOiSjlw");
        client = new JWebSocketClient(uri,map) {
            @Override
            public void onMessage(String message) {
                //message就是接收到的消息
                Log.d(TAG, "WebSocketService收到的消息：" + message);


//这里我通过EvenBus获取接收的消息并更新ui
                //EventBus.getDefault().post(new WebSocketEvent(message));
            }

            @Override
            public void onOpen(ServerHandshake handShakeData) {//在webSocket连接开启时调用
                //EventBus.getDefault().post("WebSocket 连接成功");
                Log.d(TAG, "WebSocket 连接成功" );
            }

            @Override
            public void onClose(int code, String reason, boolean remote) {//在连接断开时调用
                Log.d(TAG, "onClose() 连接断开_reason：" + reason );
                //EventBus.getDefault().post("onClose() 连接断开_reason：" + reason );
                mHandler.removeCallbacks(heartBeatRunnable);
                mHandler.postDelayed(heartBeatRunnable, CLOSE_RECON_TIME);//开启心跳检测
            }

            @Override
            public void onError(Exception ex) {//在连接出错时调用
                //EventBus.getDefault().post("onError() 连接出错：" + ex.getMessage() );
                Log.d(TAG, "onError() 连接出错：" + ex.getMessage() );
                mHandler.removeCallbacks(heartBeatRunnable);
                mHandler.postDelayed(heartBeatRunnable, CLOSE_RECON_TIME);//开启心跳检测
            }
        };
        connect();
    }

    /**
     * 连接WebSocket
     */
    private void connect() {
        new Thread() {
            @Override
            public void run() {
                try {
                    //connectBlocking多出一个等待操作，会先连接再发送，否则未连接发送会报错
                    client.connectBlocking();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }


    /**
     * 发送消息
     */
    public void sendMsg(String msg) {
        if (null != client) {

            try {
                client.send(msg);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public boolean onUnbind(Intent intent) {

        return super.onUnbind(intent);
    }

    @Override
    public void onDestroy() {
        closeConnect();
        super.onDestroy();
    }

    /**
     * 断开连接
     */
    public void closeConnect() {
        mHandler.removeCallbacks(heartBeatRunnable);
        try {
            if (null != client) {
                client.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client = null;
        }
    }
    //    -------------------------------------WebSocket心跳检测------------------------------------------------
    private static final long HEART_BEAT_RATE = 5 * 1000;

    //每隔10秒进行一次对长连接的心跳检测
    private Handler mHandler = new Handler();
    private Runnable heartBeatRunnable = new Runnable() {
        @Override
        public void run() {
            if (client != null) {
                if (client.isClosed()) {
                    reconnectWs();
                    Log.d(TAG, "心跳包检测WebSocket连接状态：已关闭" );
                    //EventBus.getDefault().post("WebSocket 已关闭");
                } else if (client.isOpen()) {
                    Log.d(TAG, "心跳包检测WebSocket连接状态：已连接" );
                    //EventBus.getDefault().post("WebSocket 已连接");
                } else {
                    //EventBus.getDefault().post("WebSocket 已断开");
                    Log.d(TAG, "心跳包检测WebSocket连接状态：已断开" );
                }
            } else {
                //如果client已为空，重新初始化连接
                initSocketClient();
                Log.d(TAG, "心跳包检测WebSocket连接状态：client已为空，重新初始化连接" );
            }
            //每隔一定的时间，对长连接进行一次心跳检测
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };
    /**
     * 开启重连
     */
    private void reconnectWs() {
        mHandler.removeCallbacks(heartBeatRunnable);
        new Thread() {
            @Override
            public void run() {
                try {
                    Log.d(TAG, "开启重连" );
                    client.reconnectBlocking();


                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
    public class AuxiliaryService extends Service {
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {

            return null;
        }
        @Override
        public void onCreate() {
            super.onCreate();

        }
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            startNotification();

            return super.onStartCommand(intent, flags, startId);
        }
        /** 启动通知*/
        private void startNotification(){

            Notification notification = new Notification();
            this.startForeground(GRAY_SERVICE_ID, notification);
            stopSelf(); //关键  如果AuxiliaryService 没有与什么组件绑定  系统就会回收
            stopForeground(true);
        }
    }
}

4.工具类

public class JWebSocketClient extends WebSocketClient {
    public JWebSocketClient(URI serverUri ,Map<String,String> map) {
        super(serverUri, new Draft_6455(),map);
    }

    @Override
    public void onOpen(ServerHandshake handshakedata) {
        Log.e("JWebSocketClient", "onOpen()");
        //ToastUtils.show(getmContext(),"onOpen()");
    }

    @Override
    public void onMessage(String message) {
        Log.e("JWebSocketClient", "onMessage():"+message);
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        Log.e("JWebSocketClient", "onClose()");
        //ToastUtils.show(getmContext(),"onClose()");
    }

    @Override
    public void onError(Exception ex) {
        Log.e("JWebSocketClient", "onError()"+ex.getMessage());
        //ToastUtils.show(getmContext(),"onError()");
    }
}

5.在appliction启动也可以在其他地方看需求别忘了在清单文件注册

public class App extends Application {
    public static Context mContext;
    public WebSocketService mWebSocketService;
    private final static String TAG = "Application";
    private static final String DEVICE_TOKEN = "device_token";//设备token
    @Override
    public void onCreate() {
        super.onCreate();
        mContext=this;
        //开启
        startWebSocketService(DEVICE_TOKEN);
    }
    private static final long HEART_BEAT_RATE = 5 * 1000;//每隔1分钟发送空消息保持WebSocket长连接
    public static Context getmContext() {
        return mContext;
    }

    private Handler mHandler = new Handler();


    private Runnable webSocketRunnable = new Runnable() {
        @Override
        public void run() {
            if (mWebSocketService != null &&
                    mWebSocketService.client != null && mWebSocketService.client.isOpen()) {
                try {
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("from","");
                    jsonObject.put("to", "");

                    mWebSocketService.sendMsg(jsonObject.toString());
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
            //每隔一定的时间，对长连接进行一次心跳检测
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };


    public WebSocketService getWebSocketService() {
        return mWebSocketService;
    }

    /**
     * 开启并绑定WebSocket服务
     */
    public void startWebSocketService(String deviceToken) {
        Intent bindIntent = new Intent(this, WebSocketService.class);
        bindIntent.putExtra(DEVICE_TOKEN, deviceToken);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            //android8.0以上通过startForegroundService启动service
            startForegroundService(bindIntent);
        } else {
            startService(bindIntent);
        }
        bindService(bindIntent, serviceConnection, BIND_AUTO_CREATE);
        mHandler.removeCallbacks(webSocketRunnable);
        mHandler.postDelayed(webSocketRunnable, HEART_BEAT_RATE);//开启心跳检测
    }


    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //服务与活动成功绑定
            mWebSocketService = ((WebSocketService.JWebSocketClientBinder) iBinder).getService();

            Log.d(TAG, "WebSocket服务与Application成功绑定");
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            //服务与活动断开
            mWebSocketService = null;
            Log.d(TAG, "WebSocket服务与Application成功断开: ");
        }
    };
}

6.至此就可简单实现Android端的代码后台有需要demo的可以私聊我

weixin_44935137
关注
webSocket实现Android客户端之间简单的通讯
09-22
webSocket实现Android客户端之间简单的通讯，或者群发
Android使用Websocket实现聊天室
08-27
Autobahn|Android 是一个开源的 Java/Android 网络库，实现了 WebSocket 协议和 Web 应用程序消息传输协议来创建本地移动的 WebSocket/WAMP 客服端。Autobahn|Android 库支持 WebSocket RFC6455、Draft Hybi-10+ 和 ...
Android 网络通信WebSocket使用详解
fusu2178192的博客
07-04 1万+
WebSocket的详细使用步骤，2022年6月写的。客户端服务端都是在android上实现的。
Android实时通信：WebSocket与WebRTC的应用与优化
最新发布
陆业聪
08-10 2439
在现代移动应用中，实时通信已经成为一项基础功能。无论是实时聊天、在线游戏，还是实时音视频通信，都需要依赖实时通信技术。本文将介绍两种在Android平台上实现实时通信的主流方法：WebSocket和WebRTC。
在Android中使用WebSocket
chuyouyinghe的专栏
01-03 1793
WebSocket是一种通信协议，它提供了一个单一的、长期的连接上的全双工通信通道。它设计用于在Web浏览器和Web服务器中实现，但也可以用于其他应用。与传统的基于请求-响应和无状态的HTTP连接不同，WebSocket允许客户端和服务器之间的双向通信。这使得实时数据交换和推送功能成为可能。
在安卓中使用WebSocket
king的专栏
06-20 5252
WebSocket是一种在Web浏览器和服务器之间进行实时双向通信的协议。与传统的HTTP请求-响应模型不同，WebSocket允许服务器主动向客户端推送数据，而不需要客户端发起请求。当然，发展到如今，WebSocket已经不再局限于Web浏览器了，也可以在移动应用、桌面应用上使用。
Android通讯-webSocket
moxiouhao的专栏
09-04 2万+
概述上一篇简单的认识了Socket以及他的使用，在学习过程中看到了WebSocket的身影，于是乎百度了一把，这货也可以做全双工的网络通讯，而且是html5提出来的新东西！程序员嘛！就是要对新的东西充满了好奇！WebSocket引用API里面的一句话，WebSocket是HTML5开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。全双工：简单理解为C,S端可以相互发送和接收数据。WebSoc
Android WebSocket 使用指南：详细步骤与实践
工宗浩生财指南针
05-12 5166
WebSocket 是一种在单个长连接上进行全双工通信的协议。相比于传统的HTTP请求，WebSocket 可以减少通信的延迟，适用于需要实时数据传输的场景，如聊天应用、游戏和实时数据更新服务。在Android开发中，WebSocket的使用可以借助OkHttp库或库来实现。
Android WebSocket实现即时通讯功能
热门推荐
程序员大佬超的博客
03-20 3万+
最近做这个功能，分享一下。即时通讯（Instant Messaging）最重要的毫无疑问就是即时，不能有明显的延迟，要实现IM的功能其实并不难，目前有很多第三方，比如极光的JMessage，都比较容易实现。但是如果项目有特殊要求（如不能使用外网），那就得自己做了，所以我们需要使用WebSocket。 WebSocket WebSocket协议就不细讲了，感兴趣的可以具体查阅资料，简而言之，它就......
安卓android+WebSocket实现简易QQ聊天室
01-03
本篇仅介绍实现聊天室的前端，也就是安卓端代码，后端的实现看链接说明 链接说明 1.后端使用了spring boot 框架，若不熟悉，有关spring boot 入门教程请戳此链接使用Intellij IDEA开发第一个spring boot项目 2....
安卓android+WebSocket实现简易QQ聊天室(前后端代码)
12-28
1.原项目地址（安卓端） https://blog.csdn.net/baidu_41860619/article/details/105267973 2.原项目地址（idea后端） ...3.安卓端代码：QQandroid idea代码：qqspringboot
android 实现websocket 长链接功能
04-19
实现websocket 长链接功能，借助 StompProtocolAndroid 实现,完成长链接功能,消息发送接受功能
Android_Websocket
01-10
在Android平台之间构建基于Websocket的消息推送系统。如果资源不可用，请告知，谢谢
Android websocket Demo
08-25
基于Android的websocket demo，封装成了小类库
websocket使用
风火一回，一生不毁
04-05 2万+
websocket，html5中新一代全双工通信协议。其底层仍然是http协议。 传统 HTTP 请求响应客户端服务器交互图 WebSocket 请求响应客户端服务器交互图 WebSocket 客户端支持 浏览器 支持情况 Chrome Chrome version 4+支持 Firefox
Android开发 WebSocket
gldzzznb的博客
01-26 6346
主要介绍了WebSocket的特点，在Http和WebSocket之间如何做技术选型，以及实现通信。
Android websocket的实现
qq_23911165的博客
06-21 144
https://blog.csdn.net/u013872857/article/details/89839204
Android中 使用 WebSocket 实现消息通信
黄林晴
05-22 8285
前言 消息推送功能可以说移动APP不可缺少的功能之一，一般简单的推送我们可以使用第三方推送的SDK，比如极光推送、信鸽推送等，但是对于消息聊天这种及时性有要求的或者三方推送不满足业务需求的，我们就需要使用WebSocket实现消息推送功能。 基本流程 WebSocket是什么，这里就不做介绍了，我们这里使用的开源框架是https://github.com/TakahikoKawasaki/n...
android 用websocket实现一对一视频
04-05
很抱歉，作为AI语言模型，我不具备编程能力，但是我可以提供一些帮助。 如果您想在Android应用程序中实现一对一视频通话，可以使用WebRTC技术。WebRTC是一个开源项目，提供了实时通信的API，可以在网页和移动应用程序中使用。 要使用WebRTC，您需要创建一个WebSocket服务器，用于建立对等连接和交换视频和音频流。您可以使用开源的WebSocket服务器，如Node.js或Java WebSocket。 在Android应用程序中，您可以使用WebRTC库，如Google的WebRTC for Android，来处理视频和音频流。您可以使用Android SDK中的摄像头和麦克风来捕获视频和音频流，并将其发送到WebSocket服务器。 在接收端，您可以使用WebRTC库处理接收到的视频和音频流，并在Android应用程序中显示它们。 需要注意的是，实现一对一视频通话需要处理许多技术细节，包括网络连接，视频编解码，音频编解码等。建议您先学习WebRTC技术，并尝试使用示例代码来实现简单的视频通话应用程序。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值