Android之Socket的基于UDP传输

转载 2017年09月01日 11:29:32

转自:http://blog.csdn.net/tianxuhong/article/details/45337103


接收方创建步骤:

1.  创建一个DatagramSocket对象,并指定监听的端口号

DatagramSocket socket = new  DatagramSocket (4567);

2. 创建一个byte数组用于接收

byte data[] = new byte[1024];

3. 创建一个空的DatagramPackage对象

 DatagramPackage package = new DatagramPackage(data , data.length);

4. 使用receive方法接收发送方所发送的数据,同时这也是一个阻塞的方法

socket.receive(package); 

5. 得到发送过来的数据

new String(package.getData() , package.getOffset() , package.getLength());

 

发送方创建步骤:

1.  创建一个DatagramSocket对象

DatagramSocket socket = new  DatagramSocket (4567);

2.  创建一个 InetAddress , 相当于是地址

InetAddress serverAddress = InetAddress.getByName("想要发送到的那个IP地址"); 

3.  这是随意发送一个数据

String str = "hello";

4.  转为byte类型

byte data[] = str.getBytes();

  5.  创建一个DatagramPacket 对象,并指定要讲这个数据包发送到网络当中的哪个地址,以及端口号

DatagramPacket  package = new DatagramPacket (data , data.length , serverAddress , 4567);

6.  调用DatagramSocket对象的send方法 发送数据

 socket . send(package);

 http://www.cnblogs.com/lee0oo0/archive/2012/04/04/2431907.html

一、有的手机不能直接接收UDP包,可能是手机厂商在定制Rom的时候把这个功能给关掉了。

1、可先在oncreate()方法里面实例化一个WifiManager.MulticastLock 对象lock;具体如下:

WifiManager manager = (WifiManager) this
                .getSystemService(Context.WIFI_SERVICE);
WifiManager.MulticastLock lock= manager.createMulticastLock("test wifi");

2、在调用广播发送、接收报文之前先调用lock.acquire()方法;

3、用完之后及时调用lock.release()释放资源,否决多次调用lock.acquire()方法,程序可能会崩,详情请见

Caused by: java.lang.UnsupportedOperationException: Exceeded maximum number of wifi locks

注;记得在配置文件里面添加如下权限:

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

经过这样处理后,多数手机都能正常发送接收到广播报文。

本小点转载自Android手机接收不到UDP报文

二、在UDP通信中,android端发送UDP广播包没有问题。至于接收的话,有时候不能接收到包。

在UDP通信中,android端发送UDP广播包没有问题。至于接收的话,有时候不能接收到包。但是如果UDP包中指定了目标主机的地址的话,那么android端就能正常接收。

下面上一段代码,大家可用这段代码进行测试。

1、在一个Service里面,我们创建一个线程

复制代码
public void onCreate() {//用于创建线程
        WifiManager manager = (WifiManager) this
                .getSystemService(Context.WIFI_SERVICE);
        udphelper = new UdpHelper(manager);
        
        //传递WifiManager对象,以便在UDPHelper类里面使用MulticastLock
        udphelper.addObserver(MsgReceiveService.this);
        tReceived = new Thread(udphelper);
        tReceived.start();
        super.onCreate();
    }
复制代码

2、弄一个UDP帮助类,这个类主要用于发送和接收数据

复制代码
package com.example.com.ihome.bang.util;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Observable;
import com.example.com.ihome.bang.tool.SendThread;
import android.net.wifi.WifiManager;
import android.util.Log;

/**
 * 
 * UdpHelper帮助类
 * 
 * @author 陈喆榕
 * 
 */
public class UdpHelper  implements Runnable {
    public    Boolean IsThreadDisable = false;//指示监听线程是否终止
    private static WifiManager.MulticastLock lock;
    InetAddress mInetAddress;
    public UdpHelper(WifiManager manager) {
         this.lock= manager.createMulticastLock("UDPwifi"); 
    }
    public void StartListen()  {
        // UDP服务器监听的端口
        Integer port = 8903;
        // 接收的字节大小,客户端发送的数据不能超过这个大小
        byte[] message = new byte[100];
        try {
            // 建立Socket连接
            DatagramSocket datagramSocket = new DatagramSocket(port);
            datagramSocket.setBroadcast(true);
            DatagramPacket datagramPacket = new DatagramPacket(message,
                    message.length);
            try {
                while (!IsThreadDisable) {
                    // 准备接收数据
                    Log.d("UDP Demo", "准备接受");
                     this.lock.acquire();
                     
                    datagramSocket.receive(datagramPacket);
                    String strMsg=new String(datagramPacket.getData()).trim();
                    Log.d("UDP Demo", datagramPacket.getAddress()
                            .getHostAddress().toString()
                            + ":" +strMsg );this.lock.release();
                }
            } catch (IOException e) {//IOException
                e.printStackTrace();
            }
        } catch (SocketException e) {
            e.printStackTrace();
        }

    }
    public static void send(String message) {
        message = (message == null ? "Hello IdeasAndroid!" : message);
        int server_port = 8904;
        Log.d("UDP Demo", "UDP发送数据:"+message);
        DatagramSocket s = null;
        try {
            s = new DatagramSocket();
        } catch (SocketException e) {
            e.printStackTrace();
        }
        InetAddress local = null;
        try {
            local = InetAddress.getByName("255.255.255.255");
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        int msg_length = message.length();
        byte[] messageByte = message.getBytes();
        DatagramPacket p = new DatagramPacket(messageByte, msg_length, local,
                server_port);
        try {

            s.send(p);
            s.close();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
            StartListen();
    }
}
复制代码


作者:kissazi2 
出处:http://www.cnblogs.com/kissazi2/
本文版权归作者所有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。



最后, 添加个人的实例 :

package com.example.android.helloactivity;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.example.andriod.udp.UDPClient;
import com.example.andriod.udp.UDPServer;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainAct extends Activity {
    EditText msg_et = null;
    Button send_bt = null;
    TextView info_tv = null;
    private static final String TAG ="MainAct";
    private UDPClient client;
    private String sendInfo;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.udp_test);
        msg_et = (EditText) findViewById(R.id.edit_msg);
        send_bt = (Button) findViewById(R.id.send_bt);
        info_tv = (TextView) findViewById(R.id.receive_msg);
        info_tv.setText("source");
        // 开启服务器
        ExecutorService exec = Executors.newCachedThreadPool();
        UDPServer server = new UDPServer();
        exec.execute(server);
        // 发送消息
        send_bt.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {

                myThread1 thread = new myThread1("22");
                new Thread(thread).start();

            }
        });
    }

    final Handler mHander = new Handler() {

        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            //super.handleMessage(msg);
            info_tv.setText(sendInfo);
            
            Log.d(TAG, "client.send()=");
        }
    };

    class myThread1 implements Runnable {

        private String threadName;

        public myThread1(String name) {
            this.threadName = name;
        }

        public void run() {
            Log.d(TAG, "MyThread  execu"+msg_et.getText().toString());
            client = new UDPClient(msg_et.getText().toString());
            sendInfo=client.send();
            
            Message msg = mHander.obtainMessage();
            msg.arg1=1;
            mHander.sendMessage(msg);
            Log.d(TAG, "client.send()=");
        }
    }
}

package com.example.andriod.udp;

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

import android.util.Log;

public class UDPServer implements Runnable {
    private static final int PORT = 6000;
    private byte[] msg = new byte[2048];
    private boolean life = true;

    public UDPServer() {
    }

    public boolean isLife() {
        return life;
    }

    public void setLife(boolean life) {
        this.life = life;
    }

    @Override
    public void run() {
        DatagramSocket dSocket = null;
        DatagramPacket dPacket = new DatagramPacket(msg, msg.length);
        try {
            dSocket = new DatagramSocket(PORT);
            while (life) {
                try {
                    dSocket.receive(dPacket);
                    Log.d("tian msg sever received",
                            new String(dPacket.getData(), dPacket.getOffset(),
                                    dPacket.getLength())
                                    + "dPacket.getLength()="
                                    + dPacket.getLength());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
}


package com.example.andriod.udp;

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

import android.util.Log;

public class UDPClient {
    private static final int SERVER_PORT = 6000;
    private DatagramSocket dSocket = null;
    private String msg;

    public UDPClient(String msg) {
        super();
        this.msg = msg;
    }

    public String send() {
        StringBuilder sb = new StringBuilder();
        InetAddress local = null;
        try {
            local = InetAddress.getByName("localhost"); // 本机测试
            sb.append("已找到服务器,连接中...").append("/n");
        } catch (UnknownHostException e) {
            sb.append("未找到服务器.").append("/n");
            e.printStackTrace();
        }
        try {
            dSocket = new DatagramSocket(); // 注意此处要先在配置文件里设置权限,否则会抛权限不足的异常
            sb.append("正在连接服务器...").append("/n");
        } catch (SocketException e) {
            e.printStackTrace();
            sb.append("服务器连接失败.").append("/n");
        }
        int msg_len = msg == null ? 0 : msg.length();
        DatagramPacket dPacket = new DatagramPacket(msg.getBytes(), msg_len,
                local, SERVER_PORT);
        try {
            dSocket.send(dPacket);
            Log.d("tian", "msg=="+msg+"dpackage="+dPacket.getData()+"dPacket.leng="+dPacket.getLength());
            sb.append("消息发送成功!").append("/n");
        } catch (IOException e) {
            e.printStackTrace();
            sb.append("消息发送失败.").append("/n");
        }
        dSocket.close();
        return sb.toString();
    }
}

Android中Socket通信之TCP与UDP传输原理

http://blog.csdn.net/u010687392/article/details/44649589 转载:Sunzxyong 一、Socket通信简介  Andro...

Android-->UDP协议的Socket数据传输

阅读之前,你已经了解了UDP的相关知识;UDP数据传输时,数据包的大小是有限制的65535, 大概是64k的内容当数据太大时,需要分包机制,后续补充…如果你有更好的分包方法,请分享给我~谢谢!接收端的...
  • angcyo
  • angcyo
  • 2016年03月22日 14:49
  • 1340

Android中Socket通信之TCP与UDP传输原理

一、Socket通信简介  Android与服务器的通信方式主要有两种,一是Http通信,一是Socket通信。两者的最大差异在于,http连接使用的是“请求—响应方式”,即在请求时建立连接通道,当...

羊皮书APP(Android版)开发系列(十二)Android Socket UDP大文件传输

业务需求是:通过电脑端(网页或客户端形式)发送文件到Android的客户端,下面是使用UDP实现的一个简单的文件传输Demo,因UDP为不可靠传输,可能会丢包。服务器端发送本地文件,代码如下: pac...

C# UDP Socket异步传输文件代码

  • 2013年07月28日 17:46
  • 402KB
  • 下载

有关socket通信包大小的问题总结(UDP传输模式)

最近刚接触linux的编程,在pc机上编了两个socket通信的程序做测试,一个采用TCP的方式,另一个采用UDP的方式。不断增大传输数据包的大小,到180k大小时,UDP通信收不到包,阻塞在recv...

C# UDP(Socket)异步传输文件

  • 2010年04月19日 17:20
  • 152KB
  • 下载

SOCKET udp tcp 传输

  • 2015年05月30日 22:10
  • 4KB
  • 下载

C# UDP(Socket)异步传输文件

用SCOKET 发送文件是一个不太好处理的问题,网上的例子也都是很简单的,我准备写一个比较完善的例子,这个就算是开始吧,以后的都会在这个例子的基础上进行修改,准备实现多线程传输、断点传输和文件传输的完...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android之Socket的基于UDP传输
举报原因:
原因补充:

(最多只允许输入30个字)