搭建局域网WebSocket手机和Web遥控器

小咪咪 2022-01-11 07:39 987阅读 0赞

![20190619222903960.png][]

这里以遥控Android平台的机顶盒或应用为例，实现基于WebSocket的遥控通信。这里以遥控机顶盒为例。WebSocket支持双向通信。**WebSocket**是一种在单个TCP连接上进行全双工通信的协议。允许服务端主动向客户端推送数据，浏览器/客户端和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。很多推送功能就是基于WebSocket进行实现的通信推送。

WebSocket优点：

*  较少的控制开销；
 *  更强的实时性；
 *  保持连接状态；
 *  更好的二进制支持；
 *  可以支持扩展；
 *  更好的压缩效果等。

更详细的WebSocket介绍和用法：

[https://developer.mozilla.org/zh-CN/docs/Web/API/WebSocket][https_developer.mozilla.org_zh-CN_docs_Web_API_WebSocket]

[http://www.websocket.org/][http_www.websocket.org]

目前有两种方式实现通信遥控：

1.  一个是基于局域网的，即服务器和客户端在一个网络下，可以在机顶盒应用里内置WebSocket服务端Server，手机和网页作为客户端发送指令。
2.  另一个是搭建一个公网中转服务器Server，手机/网页、机顶盒都作为客户端，这样客户端都需要知道服务器端地址去主动连接。这样就不会局限于同一个网络通信，手机/网页发送的消息通过服务器端中转再传统给机顶盒客户端。当然，这样也有弊端，就是增大了通信运营成本、安全性、也可能会有延迟、服务器一旦出问题，所有客户端都无法正常工作等。

先看第一种，这里采用Java搭建WebSocket服务器，内置到机顶盒内。

这里用到了开源库：**[Java-WebSocket][]（** [https://github.com/TooTallNate/Java-WebSocket][Java-WebSocket]**）**

package com.test.ws.utils;
    
    import org.java_websocket.WebSocket;
    import org.java_websocket.handshake.ClientHandshake;
    import org.java_websocket.server.WebSocketServer;
    
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    
    public class SimpleServer extends WebSocketServer {
    
        public SimpleServer(InetSocketAddress address) {
            super(address);
        }
    
        @Override
        public void onOpen(WebSocket conn, ClientHandshake handshake) {
            conn.send("Welcome to the server!"); //This method sends a message to the new client
            broadcast( "new connection: " + handshake.getResourceDescriptor() ); //This method sends a message to all clients connected
            System.out.println("new connection to " + conn.getRemoteSocketAddress());
        }
    
        @Override
        public void onClose(WebSocket conn, int code, String reason, boolean remote) {
            System.out.println("closed " + conn.getRemoteSocketAddress() + " with exit code " + code + " additional info: " + reason);
        }
    
        @Override
        public void onMessage(WebSocket conn, String message) {
            System.out.println("received message from "	+ conn.getRemoteSocketAddress() + ": " + message);
        }
    
        @Override
        public void onMessage( WebSocket conn, ByteBuffer message ) {
            System.out.println("received ByteBuffer from "	+ conn.getRemoteSocketAddress());
        }
    
        @Override
        public void onError(WebSocket conn, Exception ex) {
            System.err.println("an error occured on connection " + conn.getRemoteSocketAddress()  + ":" + ex);
        }
    
        @Override
        public void onStart() {
            System.out.println("server started successfully");
        }
    
    
        public static void main(String[] args) {
            String host = "localhost";
            int port = 8887;
    
            WebSocketServer server = new SimpleServer(new InetSocketAddress(host, port));
            server.run();
        }
    }

客户端分别给出Web和Java两个版本。

Web版本：

<!DOCTYPE HTML>
    <html>
    
    <head>
        <meta charset="utf-8" />
        <title>ws</title>
        <style type="text/css">
    
        </style>
        <script type="text/javascript">
    
            var onOpen = function () {
                console.log("Socket opened.");
                socket.send("Hi, Server!");
            },
                onClose = function () {
                    console.log("Socket closed.");
                },
                onMessage = function (data) {
                    console.log("We get signal:");
                    console.log(data);
                },
                onError = function () {
                    console.log("We got an error.");
                },
    
                socket = new WebSocket("ws://127.0.0.1:8887/");
            socket.onopen = onOpen;
            socket.onclose = onClose;
            socket.onerror = onError;
            socket.onmessage = onMessage;
    
    		function sendMessage(){
    			socket.send("Hi, Server,I send Message!");
    		}
    		function left(){
    			socket.send("left");
    		}
    		function right(){
    			socket.send("right");
    		}
    		function up(){
    			socket.send("up");
    		}
    		function down(){
    			socket.send("down");
    		}
    		function enter(){
    			socket.send("enter");
    		}
    		function back(){
    			socket.send("back");
    		}
        </script>
    </head>
    
    <body>
        <div id="connected">
        <button onclick="sendMessage()">连接</button>
        </div>
        <div id="left"><button onclick="left()">Left</button></div>
        <div id="right"><button onclick="right()">Right</button></div>
        <div id="up"><button onclick="up()">Up</button></div>
        <div id="down"><button onclick="down()">Down</button></div>
        <div id="enter"><button onclick="enter()">Enter</button></div>
        <div id="back"><button onclick="back()">Back</button></div>
    </body>
    
    </html>

Java版本：

package com.test.ws.utils;
    
    import org.java_websocket.client.WebSocketClient;
    import org.java_websocket.drafts.Draft;
    import org.java_websocket.handshake.ServerHandshake;
    
    import java.net.URI;
    import java.net.URISyntaxException;
    import java.nio.ByteBuffer;
    
    public class EmptyClient extends WebSocketClient {
    
        public EmptyClient(URI serverUri, Draft draft) {
            super(serverUri, draft);
        }
    
        public EmptyClient(URI serverURI) {
            super(serverURI);
        }
    
        @Override
        public void onOpen(ServerHandshake handshakedata) {
            send("Hello, it is me. Mario :)");
            System.out.println("new connection opened");
        }
    
        @Override
        public void onClose(int code, String reason, boolean remote) {
            System.out.println("closed with exit code " + code + " additional info: " + reason);
        }
    
        @Override
        public void onMessage(String message) {
            System.out.println("received message: " + message);
        }
    
        @Override
        public void onMessage(ByteBuffer message) {
            System.out.println("received ByteBuffer");
        }
    
        @Override
        public void onError(Exception ex) {
            System.err.println("an error occurred:" + ex);
        }
    
        public static void main(String[] args) throws URISyntaxException {
            WebSocketClient client = new EmptyClient(new URI("ws://localhost:8887"));
            client.connect();
        }
    }

在Android机顶盒端使用的时候，可以将Server放置在一个Service里后台监听运行：

package com.test.ws;
    
    import android.app.Service;
    import android.content.Intent;
    import android.os.Handler;
    import android.os.IBinder;
    import android.os.Message;
    import android.support.annotation.Nullable;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    
    public class ConnectService extends Service implements SimpleServer.MessageListener {
        private Thread thread;
        private SimpleServer server;
        private static MessageListener msgListener;
    
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            if (thread != null) {
                thread = null;
            }
            thread = new Thread() {
                @Override
                public void run() {
                    super.run();
                    server = new SimpleServer(getBaseContext(), new InetSocketAddress(Constants.HOST, Constants.PORT));
                    server.setMessageListener(ConnectService.this);
                    server.run();
                }
            };
            thread.start();
        }
    
        private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if (msgListener != null) {
                    msgListener.onMessage(msg.obj.toString());
                }
            }
        };
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            return super.onStartCommand(intent, flags, startId);
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            if (server != null) {
                try {
                    server.stop();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        @Override
        public void onMessage(String text) {
            Message message = new Message();
            message.obj = text;
            handler.sendMessage(message);
        }
    
        public static void setMessageListener(MessageListener messageListener) {
            msgListener = messageListener;
        }
    
        public interface MessageListener {
            void onMessage(String message);
        }
    }

机顶盒服务器端接收模拟按键操作：

@Override
        public void onMessage(String message) {
            switch (message) {
                case "left": {
                    sendKeyCode(KeyEvent.KEYCODE_DPAD_LEFT);
                }
                break;
                case "right": {
                    sendKeyCode(KeyEvent.KEYCODE_DPAD_RIGHT);
                }
                break;
                case "up": {
                    sendKeyCode(KeyEvent.KEYCODE_DPAD_UP);
                }
                break;
                case "down": {
                    sendKeyCode(KeyEvent.KEYCODE_DPAD_DOWN);
                }
                break;
                case "enter": {
                    sendKeyCode(KeyEvent.KEYCODE_DPAD_CENTER);
                }
                break;
                case "back": {
                    sendKeyCode(KeyEvent.KEYCODE_BACK);
                }
                break;
                default:
                    Toast.makeText(getBaseContext(), "default：" + message, Toast.LENGTH_SHORT).show();
                    break;
            }
        }
    
    // 模拟按键发送
    private synchronized void sendKeyCode(final int keyCode){
    		new Thread () {
    			public void run() {
    				try {
    					Instrumentation inst = new Instrumentation();
    					inst.sendKeyDownUpSync(keyCode);
    				} catch (Exception e) {
    					Log.e("Exception when sendPointerSync", e.toString());
    				}
    			}
    		}.start();
    	}

并在项目文件清单里加入权限：

<uses-permission android:name="android.permission.INJECT_EVENTS" />

模拟按键核心是Instrumentation这个对象，Instrumentation其实主要用来做测试的，可以模拟所有系统级别按键操作。

默认非系统应用只能模拟控制本应用内（进程内）的按键实践。只有拥有系统应用权限的才可以模拟整个Android系统的事件，包括控制其他的应用操作。

如果采用中转服务器的话，这里采用NodeJS搭建WebSocket服务器端，这里只给出一个简单的Server的搭建示例，后续完善：

var ws = require("nodejs-websocket")
    
    // Scream server example: "hi" -> "HI!!!"
    var server = ws.createServer(function(conn) {
    	console.log("New connection")
    	conn.on("text", function(str) {
    		console.log("Received " + str)
    		conn.sendText(str.toUpperCase() + "!!!")
    	})
    	conn.on("close", function(code, reason) {
    		console.log("Connection closed")
    	})
    }).listen(8001)

[20190619222903960.png]: /images/20220111/aaa7371067784213a596f7a9f3f75afc.png
[https_developer.mozilla.org_zh-CN_docs_Web_API_WebSocket]: https://developer.mozilla.org/zh-CN/docs/Web/API/WebSocket
[http_www.websocket.org]: http://www.websocket.org/
[Java-WebSocket]: https://github.com/TooTallNate/Java-WebSocket