Android Development: How to implement TCP and UDP transport

TCP and UDP are important in network transmission, as well as in Android development.

First look at what TCP and UDP are.

What is TCP?

Tcp:transmission Control Protocol Protocol TCP is a connection-oriented, reliable, byte-stream-based transport layer (Transport layer) communication protocol, which is provided by the IETF RFC 793 description (specified). In the simplified computer network OSI model, it accomplishes the functions specified by the fourth layer of the transport layer. The application layer sends a 8-byte data stream for inter-network transmission to the TCP layer, and then TCP splits the data stream into a segment of the appropriate length (the limit of the maximum Transmission Unit (MTU) of the data link layer of the network that is usually connected to the computer). TCP then passes the result packet to the IP layer, which transmits the packet over the network to the TCP layer of the receiving side entity. TCP in order to ensure that no packet loss occurs, give each byte a sequence number, while the serial number also guarantees the delivery to the receiving entity of the packet received sequentially. The receiving entity then sends a corresponding acknowledgment (ACK) to the successfully received byte, and if the sending entity does not receive a confirmation within a reasonable round trip delay (RTT), then the corresponding data (assuming it is lost) will be re-transmitted. TCP uses a checksum function to verify the data for errors, and to calculate checksums when sending and receiving.

First, after the TCP establishes the connection, both sides of the communication can carry on the data transmission simultaneously, secondly, he is full duplex, in the guarantee reliability, uses the time-out retransmission and the piggyback confirmation mechanism.

In the flow control, using the Sliding window Protocol [1], the Protocol stipulates that the window within the unacknowledged group needs to be re-transmitted.

In the congestion control, the slow-start algorithm is adopted.

What is UDP?

UDP is the abbreviation of User Datagram protocol, the Chinese name is the Subscriber packet protocol, is a connectionless transport layer protocol in the OSI Reference Model, and provides a simple and unreliable information transfer service for transaction. It is the official specification of the IETF RFC 768 that is UDP. It is used in the network as the TCP protocol to process packets. In the OSI model, the fourth layer, the transport layer, is in the upper layer of the IP protocol. UDP has the disadvantage of not providing datagram grouping, assembling, and not sorting packets, that is, when the message is sent, it is not possible to know whether or not it arrives safely and completely. UDP is used to support network applications that need to transfer data between computers. A large number of client/server mode network applications, including the network video conferencing system, require the use of UDP protocol. UDP protocol has been used for many years since its inception, although its original glory has been obscured by some similar agreements, but even today, UDP is still a very practical and feasible network Transport layer protocol.

As with the well-known TCP (Transmission Control Protocol) Protocol, the UDP protocol is located directly on the top level of the IP (Internet Protocol) protocol. Depending on the OSI (Open Systems Interconnect) Reference Model, both UDP and TCP are transport-layer protocols.

The main function of the UDP protocol is to compress the network data traffic into the form of the datagram. A typical datagram is a transmission unit of binary data. The first 8 bytes of each datagram are used to contain the header information, and the remaining bytes are used to contain the specific transmitted data.

The use of TCP and UDP in Android is exactly the same as in Java.

First we look at the TCP connection, one for the TCP connection:

There is not much to say, look directly at the code!

TCP Server-side code:

[Java]View Plaincopy

2. try {
4. Boolean Endflag = false;
6. ServerSocket ss = New ServerSocket (12345);
8. While (!endflag) {
10. //Waiting for client to connect
12. Socket s = ss.accept ();
14. BufferedReader input = new BufferedReader (Newinputstreamreader (S.getinputstream ()));
16. //Note the second parameter data is true will automatically flush, otherwise need to manually operate Output.flush ()
18. PrintWriter output = Newprintwriter (S.getoutputstream (),true);
20. String message = Input.readline ();
22. LOG.D ("TCP Demo", "message from Client:" +message);
24. OUTPUT.PRINTLN ("message received!");
26. //output.flush ();
28. if ("ShutDown". Equals (Message)) {
30. Endflag=true;
32. }
34. S.close ();
36. }
38. Ss.close ();
42. } catch (Unknownhostexception e) {
44. E.printstacktrace ();
46. } catch (IOException e) {
48. E.printstacktrace ();
50. }
52. TCP Client code:
54. ?
56. try {
58. Socket s = new socket ("localhost", 12345);
60. //Outgoing stream redirect to socket
62. OutputStream out = S.getoutputstream ();
64. //Note the second parameter data is true will automatically flush, otherwise need to manually operate Out.flush ()
66. PrintWriter output = new PrintWriter (out, true);
68. Output.println ("Hello ideasandroid!");
70. BufferedReader input = new BufferedReader (Newinputstreamreader (S
72. . getInputStream ()));
74. //Read line (s)
76. String message = Input.readline ();
78. LOG.D ("TCP Demo", "message from Server:" + message);
80. S.close ();
84. } catch (Unknownhostexception e) {
86. E.printstacktrace ();
88. } catch (IOException e) {
90. E.printstacktrace ();
92. }

Below we look at UDP:

UDP server-side code:

[Java]View Plaincopy

2. Ports that the UDP server listens on
4. Integer port = 12345;
6. //Received byte size, the data sent by the client cannot exceed this size
8. byte[] message = new byte[1024];
10. try {
12. //Establish socket connection
14. Datagramsocket datagramsocket = new Datagramsocket (port);
16. Datagrampacket datagrampacket = new Datagrampacket (Message,
18. Message.length);
20. try {
22. While (true) {
24. //Prepare to receive data
26. Datagramsocket.receive (Datagrampacket);
28. LOG.D ("UDP Demo", datagrampacket.getaddress ()
30. . Gethostaddress (). ToString ()
32. + ":" + new String (Datagrampacket.getdata ()));
34. }
36. } catch (IOException e) {
38. E.printstacktrace ();
40. }
42. } catch (SocketException e) {
44. E.printstacktrace ();
46. }

UDP Client code:

[Java]View Plaincopy

2. Public static void Send (String message) {
4. Message = (Message = = null?)    "Hello ideasandroid!": message);
6. int server_port = 12345;
8. Datagramsocket s = null;
10. try {
12. s = new Datagramsocket ();
14. } catch (SocketException e) {
16. E.printstacktrace ();
18. }
20. InetAddress local = null;
22. try {
24. //Swap server-side IP
26. Local = inetaddress.getbyname ("localhost");
28. } catch (Unknownhostexception e) {
30. E.printstacktrace ();
32. }
34. int msg_length = Message.length ();
36. byte[] Messagemessagebyte = Message.getbytes ();
38. Datagrampacket p = new Datagrampacket (Messagebyte, Msg_length, Local,
40. Server_port);
42. try {
44. S.send (P);
46. } catch (IOException e) {
48. E.printstacktrace ();
50. }
52. }

Android Development: How to implement TCP and UDP transport