Android TCP UDP 통신 (Emulator 간) 소스 코드

최근 변경된 API로 인해 아래 코드는 쓰레드 없이 사용할 경우 에러가 발생합니다. 테스트용 코드더라도 꼭 쓰레드 처리해주시기 바랍니다.

아래 소스를 짜게 된 이유와 설명 참고 문서 
- 아래의 글을 먼저 보셔야 Emulator 간에 통신을 활용 할 수 있습니다.(사실 이렇게 사용할 일은 없습니다.) 

     http://thdev.net/1 Android TCP UDP 통신 (Emulator 간) 소스 코드

 이 프로그램은 안드로이드 클라이언트에서 서버로 알파벳 "abCdefg"를 전송하면 서버에서는 "abCdefg"를 받아 "ABCDEFG"로 변환 후 클라이언트로 값을 다시 전송하고 클라이언트에서 이를 Toast를 이용하여 값을 출력합니다.

소스코드는 간단하고 JAVA에서 서버와 클라이언트 통신시 사용하는 소스 그대로 입니다.
깔끔하게 소스코드를 짜지 못했었기에 단순 참고용으로 활용하세요.^^
아래 소스코드의 문제점이나 좀더 추가되거나 빠져도 될 사항은 아래 댓글로 추가해주세요.^^

Android 2.2에서 실행 했던 프로그램 소스 입니다. 당연히 최신버전의 Android에서는 동작하지 않습니다! 


※ 소스코드 Client 부분

package tae.NetworkClient;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

public class NetworkClient extends Activity {
    /** Called when the activity is first created. */
    private EditText et;  //ui부분
    private TextView tcpout;  //ui부분 텍스트 view
    private TextView udpout;  //ui부분 텍스트 view
    private Button tcp;  //ui부분 버튼
    private Button udp;  //ui부분 버튼
    private String return_msg; //서버에서 받은 값을 저장합니다.
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        et = (EditText)findViewById(R.id.et);
        tcp = (Button)findViewById(R.id.tcp);
        udp = (Button)findViewById(R.id.udp);
        tcpout = (TextView)findViewById(R.id.tcpout);
        udpout = (TextView)findViewById(R.id.udpout);
        
        tcp.setOnClickListener(new OnClickListener() {  //TCP를 클릭했을 때

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                NetworkTCP tcp = new NetworkTCP(et.getText().toString()); //TCP 서버로 String을 전송
                return_msg = tcp.run();
                
                //Return된 String값을 Toast를 뛰어 줍니다.
                Toast t = Toast.makeText(getApplicationContext(), return_msg, Toast.LENGTH_LONG);
                t.show();
                tcpout.setText(tcpout.getText() + return_msg);
            }
        });
        
        udp.setOnClickListener(new OnClickListener() { //UDP 버튼을 클릭했을 때

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                NetworkUDP udp = new NetworkUDP(et.getText().toString()); //UDP 서버로 String을 전송
                return_msg = udp.run();
                
                //Return된 String값을 Toast를 뛰어 줍니다.
                Toast t = Toast.makeText(getApplicationContext(), return_msg, Toast.LENGTH_LONG);
                t.show();
                udpout.setText(udpout.getText() + return_msg);
            }
        });
    }
}

※ 소스코드 Client TCP 부분

package tae.NetworkClient;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import android.util.Log;

public class NetworkTCP {
    private static final String serverIP = "10.0.2.2";  //서버 IP를 적어 줍니다. IP부분은 Android TCP UDP 통신 (Emulator 간)를 참고하세요.
    private static final int port = 7000;  //서버에서 설정한 포트번호를 적어줍니다.
    private String msg;
    private String return_msg;
        
    public NetworkTCP(String _msg) {
        this.msg = _msg; //msg에 input에 작성한 코드를 복사 합니다.
    }
    
    public String run() {
       //java의 TCP 소스와 동일합니다.
        try {
            InetAddress serverAddr = InetAddress.getByName(serverIP); //서버 IP를 InetAddress의 serverAddr에 추가합니다.
            Log.d("TCP", "connection....");
                
            Socket socket = new Socket(serverAddr, port);  //Socket에 serverAddr, port를 이용하여 접속 합니다.
            Log.d("TCP", "socket.....");
                
            try {
                //메시지 전송을 합니다.
                Log.d("TCP", "Sending : " + msg);
                PrintWriter out = new PrintWriter(new BufferedWriter(new  OutputStreamWriter(socket.getOutputStream())), true);
                out.println(msg);
                Log.d("TCP", "Sent.");
                Log.d("TCP", "Done.");
                
                //서버에서 처리된 메시지를 다시 받아 옵니다.
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                return_msg = in.readLine();
                
                Log.d("TCP", "Server send to me this message --> " + return_msg);
            } catch(Exception e) {
                Log.e("TCP", "Error");
                
            } finally {
                socket.close();
            }
        } catch (Exception e) {
            Log.e("TCP", "Error2", e);
        }
            
        return return_msg;
    }
}

※ 소스코드 Client UDP 부분

package tae.NetworkClient;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import android.util.Log;

public class NetworkUDP {
    private static final String serverIP = "10.0.2.2"; //serverIP를 추가합니다.
    private static final int port = 8000; //서버에서 설정한 UDP 포트번호를 추가합니다.
    private String msg;
    private String return_msg;
        
    public NetworkUDP(String _msg) {
        this.msg = _msg;
    }
    
    public String run() {
        try {
            DatagramSocket socket = new DatagramSocket();
            
            InetAddress serverAddr = InetAddress.getByName(serverIP);
            
//TCP와 다르게 UDP는 byte단위로 데이터를 전송합니다. 그래서 byte를 생성해줍니다.
            byte[] buf = new byte[128];
            
            //받아온 msg를 바이트 단위로 변경합니다.
            buf = msg.getBytes();
            
            //DatagramPacket를 이용하여 서버에 접속합니다.
            DatagramPacket Packet = new DatagramPacket(buf, buf.length, serverAddr, port);
            Log.d("UDP", "sendpacket.... " + new String(buf));
            socket.send(Packet);
            Log.d("UDP", "send....");
            Log.d("UDP", "Done.");

            socket.receive(Packet);
            Log.d("UDP", "Receive" + new String(Packet.getData()));

            //데이터를 받아와 return_msg에 복사합니다.
            return_msg = new String(Packet.getData());

        } catch (Exception ex) {
            Log.d("UDP", "C: Error", ex);
            }
        return return_msg;
       }
}

※ 소스코드 Client UI 부분

<!--?xml version="1.0" encoding="utf-8"?-->

<linearlayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent">

<edittext android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/et"></edittext>

<textview android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/tcpout" android:text="TCP Output : "></textview>

<textview android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/udpout" android:text="UDP Output : "></textview>

<button android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/tcp" android:text="tcp"></button>

<button android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/udp" android:text="udp"></button>

</linearlayout>

※ 소스코드 Server TCP 부분

package tae.NetworkTCP;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class NetworkTCP extends Activity {
    private int port = 7000;  //TCP의 포트를 7000번으로 설정합니다.
    private Socket socket;
    String str;
        
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
                    
        setTCP();
    }
    
    /** Called when the activity is first created. */
    public void setTCP() {
        try {
            ServerSocket serverSocket = new ServerSocket(port); //7000번 포트로 서버를 시작합니다.
            Log.d("Green", "Waiting...");
            
            while(true) { //Client에서 요청을 기다려야 하기 때문에 while문을 사용합니다.
             socket = serverSocket.accept();
             Log.d("Green", "Accept...");

             try {
                //client에서 server로 전송된 String을 읽어 들입니다.
                BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String str = reader.readLine();
                Log.d("Green", "Received : " + str);
                            
                str = str.toUpperCase(); //읽어들인 String을 대문자로 변경합니다.
                Log.d("Green", "UpperCase : " + str);
                
                //다시 Client로 돌려보냅니다.
                PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
                writer.println(str);
                Log.d("Green", "socket : " + str);
                writer.flush();

            } catch(Exception e) {
                Log.d("Green", "catch");
                e.printStackTrace();
                
            } finally {
                Log.d("Green", "finally");
                socket.close();
            }
            }
        } catch (Exception ex) {}
    }
}

※ 소스코드 Server UDP 부분

package tae.NetworkUDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class NetworkUDP extends Activity {
    private int port = 8000;
    private DatagramSocket socket;
    private DatagramPacket receivePacket;
    String str;
    
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
                
        setUDP();
    }
    
   public void setUDP() {
       try {
           socket = new DatagramSocket(port); //8000 port로 UDP 서버를 실행합니다.
           Log.d("UDP", "S: Connecting...");
           
           byte[] buf = new byte[128];  //byte를 선언 합니다.
            
           while(true) {  //Client에서 요청을 기다려야 하기 때문에 while문을 사용합니다.
               receivePacket = new DatagramPacket(buf, buf.length); 
               Log.d("UDP", "S: Receiving...");
            
               socket.receive(receivePacket);
               Log.d("UDP", "S: Received : " + new String(receivePacket.getData()) + "");
              Log.d("UDP", "S: Done.");

              InetAddress clientAddr = receivePacket.getAddress();
              port = receivePacket.getPort();
            
              String s = new String(receivePacket.getData()); //String을 복사합니다.
              Log.d("UDP", "Receive : " + s);
              s = s.toUpperCase(); //대문자로 변환합니다.
              buf = s.getBytes(); //Byte단위로 변환합니다.
              Log.d("UDP", "UpperCase : " + s);
                
              //Client로 다시 전송합니다.
              receivePacket = new DatagramPacket(buf, buf.length, clientAddr, port);
              Log.d("UDP", "Send " + new String(buf));
              socket.send(receivePacket);
            }
       } catch (Exception ex) {
           Log.e("UDP", "S: Error", ex);
       }
    }
}

결과 화면은 이전 Android 통신 에서 확인 하세요.

- 아래의 글을 먼저 보셔야 Emulator 간에 통신을 활용 할 수 있습니다.(사실 이렇게 사용할 일은 없습니다.) 

     http://thdev.net/1 Android TCP UDP 통신 (Emulator 간) 소스 코드