UDP-NIO for Android(Client)

한글 블로그로 보기

udp_nio.zip

I tested Android(udp client)-Docklight(udp server)

MainActivity.java

1.     @Override
2.     public void onClick(View v) {
3.         switch(v.getId()){
4.        
5.         case R.id.connect:
6.             String ip=ipaddr.getText().toString();
7.             int portNum=Integer.parseInt(port.getText().toString());
8.            
9.             try{
10.                 client=new UdpClient(ip,portNum);
11.             }catch(IOException e){
12.                 e.printStackTrace();
13.             }
14.             InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);  
15.             imm.hideSoftInputFromWindow(ipaddr.getWindowToken(), 0);
16.             client.start();
17.             connect.setEnabled(false);
18.             disconnect.setEnabled(true);
19.             text.setText("Connected\n");
20.              break;
21.         case R.id.disconnect:
22.            
23.             connect.setEnabled(true);
24.             disconnect.setEnabled(false);  
25.             text.setText("Disconnected\n");
26.             break;
27.        
28.         case R.id.sendBtn:
29.             String message;
30.             message=msg.getText().toString();
31.             Message m=new Message();
32.             m.what=MSG;
33.             m.obj="Client : "+message;
34.             mHandler.sendMessage(m);
35.             sendingMsg(message);
36.            
37.             break;
38.        
39.         default:
40.         break;
41.         }
42.        
43.     }

Line 5~20 : touched connect button.

Line 10 : Creating Object(thread)

Line 16 : start thread

Line 21~26 : touched disconnect button.

Line 28~37 : touched send button.

udpclient.java (reading)

1. public class UdpClient extends Thread {
2.     MainActivity main;
3.     private final String hostAddress;
4.     private int port=5000;
5.     public static final int BUFFER_SIZE=2048;
6.     public final static int DEFAULT_PORT=5000;
7.    
8.     private Boolean loop;
9.     private static final long TIME_OUT=1000;
10.    
11.     public static DatagramChannel channel=null;
12.    
13.     public UdpClient(String Addr,int port) throws IOException{
14.     this.hostAddress=Addr;
15.     this.port=port;
16.    
17.     MainActivity.thread=new HandlerThread("HandlerThread",Process.THREAD_PRIORITY_BACKGROUND);
18.     MainActivity.thread.start();
19.     Looper mLooper=MainActivity.thread.getLooper();
20.     MainActivity.mServicehandler=new ServiceHandler(mLooper);
21.     
22.     channel=DatagramChannel.open();
23.     MainActivity.selector=Selector.open();
24.    
25.     }
27.    
28.     @Override
29.     public void run() {
30.        
31.        
32.         try{
33.             final ByteBuffer readBuffer=ByteBuffer.allocate(BUFFER_SIZE);
34.             channel.configureBlocking(false);
35.             channel.connect(new InetSocketAddress(hostAddress, port));
36.             channel.register(MainActivity.selector, SelectionKey.OP_READ);
37.            
38.            
39.            
40.            
41.             loop=true;
42.             while(loop){
43.                
44.                 Log.e("chk", "before");
45.                 if(MainActivity.selector.select(TIME_OUT)==0)
46.                     continue;
47.                
48.                 Set<SelectionKey> readKeys=MainActivity.selector.selectedKeys();
49.                 Iterator<SelectionKey> iterator=readKeys.iterator();
50.                 Log.e("chk", "after");
51.                 while(iterator.hasNext()){
52.                    
53.                     SelectionKey key=iterator.next();
54.                     iterator.remove();
55.                    
56.                     if(key.isReadable()){
57.                         readBuffer.clear();
58.                         int length=channel.read(readBuffer);
59.                         readBuffer.flip();
60.                         byte[] receivedData=new byte[length];
61.                         System.arraycopy(readBuffer.array(), 0, receivedData,0, length);
62.                         String line=new String(receivedData);
63.                        
64.                         Message m2=new Message();
65.                         m2.what=MainActivity.MSG;
66.                         m2.obj="Server : "+line;
67.                         if(m2.obj!=null)
68.                         MainActivity.mHandler.sendMessage(m2);
69.                     }
70.                 }
71.             }
72.         }catch(IOException e){
73.             e.printStackTrace();
74.         }finally{
75.             try{
76.                 channel.close();
77.             }catch(IOException e){
78.                 e.printStackTrace();
79.             }
80.            
81.         }
82.     }
83.     public void quit(){
84.         loop=false;
85.         try{
86.             channel.close();
87.         }catch(IOException e){
88.            
89.         }
90.         MainActivity.thread.quit();
91.         MainActivity.thread.interrupt();
92.     }
93. }

Line 17~20 : creating HandlerThread Object and start.

Line 22~23 : open DatagramChannel and selector.

Line 34 : DatagramChannel setting NIO.

Line 35 : Connect.

Line 36 : Selector type set to Read Operation.

Line 42~71 : Reading loop.

Line 48~49 : If selector detected receive packet, transfer element.

Line 57~62 : reading.

Line 64~68 : display message.

Line 83~92 : disconnect datagramchannel

ServiceHandler.java(send)

1. public final class ServiceHandler extends Handler{
2.     private final ByteBuffer writeBuffer;
3.    
4.    
5.     public ServiceHandler(Looper looper){
6.         super(looper);
7.         writeBuffer=ByteBuffer.allocate(UdpClient.BUFFER_SIZE);
8.     }
10.     @Override
11.     public void handleMessage(Message msg) {
12.         writeBuffer.clear();
13.         String s=(String)msg.obj;
14.         writeBuffer.put(s.getBytes());
15.        
16.         writeBuffer.flip();
17.         try{
18.             UdpClient.channel.write(writeBuffer);
19.         }catch(IOException e){
20.             e.printStackTrace();
21.         }
22.         super.handleMessage(msg);
23.     }
24.    
25.    
26. }

Line 10~23 : sending message(from sending button of Mainactivity.java )