android之同一wifi下两台设备通过UDP进行通讯

参考文章地址：http://www.cocoachina.com/android/20171016/20806.html

前端布局如下：

Activity中的全部代码，其中使用了butterknife实现View中控件的实例化。

package com.example.a260219.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import java.net.DatagramPacket;

import butterknife.ButterKnife;
import butterknife.InjectView;
import butterknife.OnClick;
import utils.UDPSocket;


public class AndroidUdpNewAcitivity extends AppCompatActivity {

    @InjectView(R.id.tv_receive_ip)
    EditText tvReceiveIp;
    @InjectView(R.id.tv_receive_port)
    TextView tvReceivePort;
    @InjectView(R.id.btn_start)
    Button btnStart;
    @InjectView(R.id.tv_service_msg)
    EditText tvServiceMsg;
    @InjectView(R.id.btn_send)
    Button btnSend;
    @InjectView(R.id.btn_reset)
    Button btnReset;
    @InjectView(R.id.tv_received_ip)
    TextView tvReceivedIp;
    @InjectView(R.id.tv_receive_msg)
    TextView tvReceiveMsg;

    private UDPSocket socket;
    private String rip;//接收端ip
    private String sip;//服务端ip
    private int port;
    private String message;
    private DatagramPacket receivePacket;
    int count = 0;
    public Handler mhandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            receivePacket = (DatagramPacket) msg.obj;
            String strReceive = new String(receivePacket.getData(), 0, receivePacket.getLength());
            tvReceivedIp.setText(receivePacket.getAddress().getHostAddress());
            tvReceivePort.setText(receivePacket.getPort() + "");
            tvReceiveMsg.setText(strReceive);
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_new_udp);
        ButterKnife.inject(this);
    }

    public void myToast(String str) {
        Toast.makeText(AndroidUdpNewAcitivity.this, str, Toast.LENGTH_SHORT).show();
    }

    @OnClick({R.id.btn_start, R.id.btn_send,R.id.btn_reset})
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.btn_start:
                if(TextUtils.isEmpty(tvReceiveIp.getText())||TextUtils.isEmpty(tvReceivePort.getText())){
                    myToast("接收端ip或者port不能为空");
                    return;
                }

                rip=tvReceiveIp.getText().toString();
                port=Integer.parseInt(tvReceivePort.getText().toString());

                if(socket==null){
                    socket = new UDPSocket(rip, port, this);
                }
                //注册回调函数
                socket.setUIUpdateListener(new UDPSocket.UIUpdateListener() {
                    @Override
                    public void upUI(DatagramPacket receivePacket) {
                        Message msg = new Message();
                        msg.obj = receivePacket;
                        mhandler.sendMessage(msg);
                    }
                });
                break;
            case R.id.btn_send:
                if(TextUtils.isEmpty(tvServiceMsg.getText().toString())){
                    myToast("发送消息不能为空");
                    return;
                }
                message=tvServiceMsg.getText().toString();
                ++count;//记录点击发送的次数
                socket.sendMessage(message+count);
                break;
            case R.id.btn_reset:
                tvReceivedIp.setText("");
                tvReceiveMsg.setText("");
                break;
        }
    }


}

---------------------------

UDPSocket.java中的代码：

 //接口规范
    public interface  UIUpdateListener {
        void upUI(DatagramPacket receivePacket);
    }
    public void setUIUpdateListener(UIUpdateListener listener){
            startUDPSocket(listener);
    }

    public void startUDPSocket(UIUpdateListener listener) {
        if (client != null) return;
        try {
         
            client = new DatagramSocket(CLIENT_PORT);

            if (receivePacket == null) {
          
                receivePacket = new DatagramPacket(receiveByte, BUFFER_LENGTH);
            }

            startSocketThread(listener);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    /**
     * 接收数据
     */
    private void startSocketThread(final UIUpdateListener listener) {
        clientThread = new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "clientThread is running...");
                receiveMessage(listener);
            }
        });
        isThreadRunning = true;
        clientThread.start();
 
    }

    /**
     * 处理接受到的消息
     */
    private void receiveMessage(UIUpdateListener listener) {
        while (isThreadRunning) {
            try {
                if (client != null) {
                    client.receive(receivePacket);
                }
                lastReceiveTime = System.currentTimeMillis();
                Log.d(TAG, "receive packet success...");
            } catch (IOException e) {
                Log.e(TAG, "UDP数据包接收失败！线程停止");
                stopUDPSocket();
                e.printStackTrace();
                return;
            }

            if (receivePacket == null || receivePacket.getLength() == 0) {
                Log.e(TAG, "无法接收UDP数据或者接收到的UDP数据为空");
                continue;
            }

            //解析接收到的 json 信息

            // 每次接收完UDP数据后，重置长度。否则可能会导致下次收到数据包被截断。
            if (receivePacket != null) {
                listener.upUI(receivePacket);
                receivePacket.setLength(BUFFER_LENGTH);
            }
        }
    }

    public void stopUDPSocket() {
        isThreadRunning = false;
        receivePacket = null;
        if (clientThread != null) {
            clientThread.interrupt();
        }
        if (client != null) {
            client.close();
            client = null;
        }
        if (timer != null) {
            timer.exit();
        }

/**
 * 发送
 */
public void sendMessage(final String message) {
    this.BROADCAST_MSG=message;
    mThreadPool.execute(new Runnable() {
        @Override
        public void run() {
            try {
                InetAddress targetAddress = InetAddress.getByName(BROADCAST_IP);

                DatagramPacket packet = new DatagramPacket(message.getBytes(), message.length(), targetAddress, CLIENT_PORT);

                client.send(packet);

                // 数据发送事件
                Log.d(TAG, "数据发送成功");

            } catch (UnknownHostException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    });
}		
    }

-----------------

总结：

注意在发送之前，需要先点击开启。

在开启的方法中，红色加粗部分的代码 socket.setUIUpdateListener， 是注册的回调函数（后续解释这个回调函数），在这个函数中执行了接受消息的语句。接受和发送消息，需要使用 DatagramSocket套接字和DatagramPacket数据包组装发送和接收的数据， 因为发送和接受信息会阻塞线程，所以发送和接受的方法需要写在子线程中。

发送端：伪代码

1.首先，创建一个发送的DatagramSocket

client = new DatagramSocket(CLIENT_PORT);

2.获取接收端的ip地址

InetAddress local = null;

try {

// 换成服务器端IP

local = InetAddress. getByName (ip);

} catch (UnknownHostException e) {

e.printStackTrace();

}

3.定义发送信息的字节数组

byte[] messageByte = message.getBytes();

4.创建DatagramPacket包组装数据，然后发送出去

DatagramPacket p = new DatagramPacket(messageByte, msg_length, local,

server_port);

try {

s.send(p);

} catch (IOException e) {

e.printStackTrace();

}

接收端：

1.创建一个接收消息的字节数组，并规定数组的长度

byte[] message = new byte[1024];

2.创建接收的DatagramSocket

client = new DatagramSocket(CLIENT_PORT);

3.创建接收数据的DatagramPacket

receivePacket = new DatagramPacket(receiveByte, BUFFER_LENGTH);

client.receive(receivePacket);

补充：说说回调函数。

参考地址： https://blog.csdn.net/a78270528/article/details/46918601

在UDPSocket类中接收到数据以后，需要把接收的数据显示在界面上，使用的回调函数。

什么是回调函数， 简单来说：回调函数就是预留给系统调用的函数，而且我们往往知道该函数被调用的时机。就好比这个项目中，回调函数是预留给Activity调用的，当接收到信息的时候进行回调，接收到信息进行UI界面更新的过程就叫”回调“。

如下图：

1.在UDPSocket类中定义一个接口（规范）

2.在Activity中注册接口，提前告诉系统这里有UI的方法等待调用，该方法具体实现更新UI。

3.在UDPSocket类中定义方法开启接受信息的方法，收到消息后调用更新UI的接口，告诉系统要调用注册的监听里的方法了。