UDP协议实现rn app之间通信

最近要求要用rn做一个udp通信的软件,首先先了解下这些udp这些概念。
然后在android里面开始写组件

简单介绍

这里需要用到DatagramSocket方法

1
2
3
4
5
6
7
8
9
try {
/******* 接收数据流程**/
// 创建一个数据报套接字,并将其绑定到指定到当前要发送的端口,如8084
datagramSocket = new DatagramSocket(8084);
// 组装数据报,绑定要发送的ip地址,本地测试如127.0.0.1
inetAddress = new InetSocketAddress("127.0.0.1", 8085);
} catch (SocketException e) {
e.printStackTrace();
}

创建好了连接就发送信息

1
2
3
4
5
6
7
8
9
10
11
12
public void sendMsg(String data){
// 要发送的数据data
mes = data;
byte[] buf = mes.getBytes();
DatagramPacket sendPacket = new DatagramPacket(buf, buf.length, inetAddress);
try{
// 组装成功后发送
datagramSocket.send(sendPacket);
}catch (IOException e){
e.printStackTrace();
}
}

接收信息,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public void receive(){
try {
if (receiveSocket == null) {
// 创建DatagramSocket,绑定8085端口,
receiveSocket = new DatagramSocket(8085);
}
// 预留1024字节缓冲区
byte[] bytes = new byte[1024];
datagramPacket= new DatagramPacket(bytes, 0, bytes.length);
// 启用新线程监听receive方法,因为receiveSocket.receive() 方法会阻塞线程,
// 所有必须要开新的线程
newThreads = new Thread(new NewThread());
newThreads.start();
} catch (SocketException e) {
e.printStackTrace();
}
}
// 创建线程
class NewThread extends Thread{
@Override
public void run() {
// 因为 receiveSocket.receive是阻塞方法,只有接收到数据后,才会执行下一个for循环内容,
// 这里可以随便给个最大值,比如100000
for(int i = 0 ; i < 100000 ; i++) {
try {
receiveSocket.receive(datagramPacket);
// 获取接收到的数据(为string类型),然后去掉前后的空格
String msg = new String(datagramPacket.getData()).trim();
// 把数据组合成 jsonobject
JSONObject msgObj = new JSONObject();
try{
msgObj.put("msgs", msg);
}catch (JSONException e){
e.printStackTrace();
}
// 然后放到jsonarray里面,我这里最好是以json的格式传到rn的
message.put(msgObj);
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

有的手机接收不到通知

如果你的手机收不到通知,其他的可以,那么你的手机应该是把接受广播的功能关了,因为手机为了省电吧,
执行下面的打开接收通知就可以了,

1
2
3
4
WifiManager wifiManager = (WifiManager)getApplicationContext().getSystemService(WIFI_SERVICE);
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
multicastLock=wifiManager.createMulticastLock("multicast.test");
multicastLock.acquire();

上面方法在MainActivity里面的onCreate里面执行

全部代码:

发送数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.socket;

import android.util.Log;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class DatagramServer {
private int MAX_LENGTH = 1024; // 最大接收字节长度
private int port = 8084;
private byte[] receMsgs = new byte[MAX_LENGTH];
private DatagramSocket datagramSocket = null;
private DatagramPacket datagramPacket = null;
public String message = "";
private String tag = "sockets";
private String mes= "i had send";
private InetSocketAddress inetAddress;
public void openServer(){
try {
datagramSocket = new DatagramSocket(port);
inetAddress = new InetSocketAddress("127.0.0.1", 8085);
} catch (SocketException e) {
e.printStackTrace();
}
}

public void sendMsg(String data){
mes = data;
byte[] buf = mes.getBytes();
inetAddress = new InetSocketAddress("127.0.0.1", 8085);
DatagramPacket sendPacket = new DatagramPacket(buf, buf.length, inetAddress);
try{
datagramSocket.send(sendPacket);
}catch (IOException e){
e.printStackTrace();
}
}
}

接收数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package com.socket;
import android.util.Log;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.WritableMap;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

public class DatagramClint {

private DatagramSocket receiveSocket = null;
private int receivePort = 8085;
private DatagramPacket datagramPacket;
public JSONArray message = new JSONArray();
private String tag = "sockets";
private Thread newThreads;
public void receive(){
try {
if (receiveSocket == null) {
receiveSocket = new DatagramSocket(receivePort);
}
byte[] bytes = new byte[1024];
datagramPacket= new DatagramPacket(bytes, 0, bytes.length);
newThreads = new Thread(new NewThread());
newThreads.start();
} catch (SocketException e) {
e.printStackTrace();
}
}

class NewThread extends Thread{
@Override
public void run() {
for(int i = 0 ; i < Integer.MAX_VALUE ; i++) {
try {
receiveSocket.receive(datagramPacket);
Long times = new Date().getTime();
String msg = new String(datagramPacket.getData()).trim();
JSONObject tmpObj = new JSONObject();
try{
tmpObj.put("msgs", msg);
tmpObj.put("time", times);
}catch (JSONException e){
e.printStackTrace();
}
message.put(tmpObj);
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

}

}

封装成rn方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package com.socket;

import android.util.JsonToken;
import android.util.Log;

import com.facebook.react.bridge.Callback;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;

import org.json.JSONArray;

public class DatagramUtils extends ReactContextBaseJavaModule{
ReactApplicationContext context;

private DatagramClint datagramClint;
private DatagramServer datagramServer;
public DatagramUtils(ReactApplicationContext reactContext) {
super(reactContext);
context = reactContext;
}

@Override
public String getName(){
return "datagram";
}

@ReactMethod
public void serverOpent(){
datagramServer = new DatagramServer();
datagramServer.openServer();
}

@ReactMethod
public void sendMsg(String mes){
datagramServer.sendMsg(mes);
}

@ReactMethod
public void clintOpent(){
datagramClint = new DatagramClint();
datagramClint.receive();
}
@ReactMethod
public void receiveMsg(Callback calback){
String data = "";
// 以string的方式传递数据
calback.invoke(datagramClint.message.toString());
}
}

package rn的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.socket;
import com.facebook.react.ReactPackage;
import com.facebook.react.bridge.NativeModule;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.uimanager.ViewManager;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class DatagramPackage implements ReactPackage{
@Override
public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
return Collections.emptyList();
}
@Override
public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
List<NativeModule> modules = new ArrayList<>();
modules.add(new DatagramUtils(reactContext));
return modules;
}
}

添加到主函数里面

1
2
3
4
5
6
7
@Override
protected List<ReactPackage> getPackages() {
return Arrays.<ReactPackage>asList(
new MainReactPackage(),
new DatagramPackage()
);
}

前端用法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import {
NativeModules,
} from 'react-native';

// 首先打开通信
NativeModules.datagram.clintOpent();
NativeModules.datagram.serverOpent();
//然后根据方法传递过去信息
press() {
NativeModules.datagram.sendMsg(this.state.text);

// 这里返回监听的数据
NativeModules.datagram.receiveMsg(rs=>{
this.setState({
// 返回回来的string数据转换成数组,
data: JSON.parse(rs)
})
});
}

缓存问题

在实现发送信息的时候会出现,当下次接收到的数据字(a长度)节小于前一次的(b长度)的时候,接收到的信息只会更新前a个数据,b-a后面的数据依然存在,比如第一次发送abc,第二次发送12,这时接收到的数据就是12c而不是我们想要的12。 这时因为udp存在缓存问题,所以要清空缓存。

清空缓存方法

方法:在取出数据后,执行如下方法

1
2
3
4
// 上面的这个创建缓存区的方法可以提取出来
byte[] bytes = new byte[1024];
// 然后在
Arrays.fill(bytes,(byte)0);

然后就清空了缓存区域

广播问题

需要先了解下ip和子网掩码二进制转化:
IP地址是一个32位的二进制数,通常被分割为4个“8位二进制数”(也就是4个字节)。IP地址通常用“点分十进制”表示成(a.b.c.d)的形式,其中,a,b,c,d都是0~255之间的十进制整数。例:点分十进IP地址(100.4.5.6),实际上是32位二进制数(01100100.00000100.00000101.00000110)

假如计算机的IP位址是192.15.156.205,子网掩码是255.255.255.224,
先把子网掩码255.255.255.224做 NOT 运算﹐可以得出﹕
00000000.00000000.00000000.00011111
然后再和IP做一次 OR 运算﹐就可以得到 Broadcast Address:
11000000.00001111.10011100.11001101 OR 00000000.00000000.00000000.00011111
(192.15.156.205 OR 255.255.255.224)
得出﹕ 11000000.00001111.10011100.11011111
(192.15.156.223)
192.15.156.223就是那个子网的广播地址了. 知道广播地址后就可以以这个地址来发送消息了,局域网的都可以接收到了。

当网络间进行通信时,如需确定是否在同一网络,则用某台主机的网络号与另一台主机的子网掩码进行与运算,观察网络号与与运算的结果是否相同。
其中还有了解下子网掩码,不然还是不知所以,子网掩码

参考地址
参考地址