Android开发之无线遥控器

最近弄了一个UDP/TCP的小东西，主要需要实现的功能如下（服务器端）：

1、基于局域网

2、服务器端网络接口为无线与有线

3、服务器端接收到客户端的数据需要模拟按键进行处理

4、开机自启动

5、使用UDP进行连接，TCP进行通讯

基于以上几点，我们开始分析：

1.需要获取当前的网络IP地址，这里枚举了本机所有的网络地址，只返回ipv4

 public String getAddressIP() {
         //检查网络是否连接
         while (!isNetWorkConnected()) {
             //等待网络连接
         }
         ip = getLocalIpAddress();
         return ip;
     }

     public String getLocalIpAddress() {
         String address = null;
           try {
             for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
               NetworkInterface intf = en.nextElement();
               for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
                 InetAddress inetAddress = enumIpAddr.nextElement();
                 if (!inetAddress.isLoopbackAddress()) {//127.0.0.1
                     address = inetAddress.getHostAddress().toString();
                     //ipV6
                     if(!address.contains("::")){
                         return address;
                     }
                 }
               }
             }
           } catch (SocketException ex) {
               Log.e("getIpAddress Exception", ex.toString());
           }
           return null;
         } 

     private boolean isNetWorkConnected() {
         // TODO Auto-generated method stub
         try{
             connectivity = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
             if(connectivity != null){
                 netWorkinfo = connectivity.getActiveNetworkInfo();
                 if(netWorkinfo != null && netWorkinfo.isAvailable()){
                     if(netWorkinfo.getState() == NetworkInfo.State.CONNECTED){
                         isConnected = true;
                         return true;
                     }
                 }
             }
         }catch(Exception e){
             Log.e("UdpService : ",e.toString());
             return false;
         }
         return false;
     }

2.获得IP之后，创建一个多播组

     　　try {

             while(ip == null){
                 ip = getAddressIP();
             }

             inetAddress = InetAddress.getByName(BROADCAST_IP);//多点广播地址组
             multicastSocket = new MulticastSocket(BROADCAST_PORT);//多点广播套接字
             multicastSocket.setTimeToLive(1);
             multicastSocket.joinGroup(inetAddress);

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

这里设置一组特殊网络地址作为多点广播地址，第一个多点广播地址都被看作是一个组，当客户端需要发送接收广播信息时，加入该组就可以了。

IP协议为多点广播提供这批特殊的IP地址，这些IP地址范围是224.0.0.0---239.255.255.255，其中224.0.0.0为系统自用。

下面BROADCAST_IP是自己声明的一个String类型的变量，其范围也是前面所说的IP范围，比如BROADCAST_IP="224.224.224.224"。

     private static int BROADCAST_PORT = 1234;
     private static int PORT = 4444;
     private static String BROADCAST_IP = "224.0.0.1";

3.服务端开始发送本机IP地址广播，如果网络断开，则结束掉此线程，并设置标识

     public class UDPBoardcastThread extends Thread {
         public UDPBoardcastThread() {
             this.start();
         }

         @Override
         public void run() {
             DatagramPacket dataPacket = null;
             //将本机的IP地址放到数据包里
             byte[] data = ip.getBytes();
             dataPacket = new DatagramPacket(data, data.length, inetAddress, BROADCAST_PORT);
             //判断是否中断连接了
             while (isNetWorkConnected()) {
                 try {
                     multicastSocket.send(dataPacket);
                     Thread.sleep(5000);
                     Log.i("UDPService:","再次发送ip地址广播");
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
             isConnected = false;
             Message msg = new Message();
             msg.what = 0x0001;
             mHandler01.sendMessage(msg);

         }
     }

4.新开一个线程，等待客户端连接，使用TCP进行通讯

             new Thread() {
                 @Override
                 public void run() {
                     try {
                     //建立一个线程池，每次收到一个客户端，新开一个线程
                     mExecutorService = Executors.newCachedThreadPool();
                     Socket client = null;
                     mList.clear();
                     while (isConnected) {

                         client = server.accept();
                         //把客户端放入客户端集合中
                         if (!connectOrNot(client)) {
                             mList.add(client);
                             Log.i("UDPService","当前连接数："+mList.size());
                         }
                         mExecutorService.execute(new Service(client));
                     }
                     //释放客户端
                     for(int i = 0 ; i < mList.size() ; i++)
                         mList.get(i).close();

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

5.新开一个客户端的线程，处理客户端发送过来的数据等

     //客户端线程，组成线程池
     class Service implements Runnable {
         private Socket socket;
         private BufferedReader in = null;
         private String msg = "";

         public Service(Socket socket) {
             this.socket = socket;
         }

         @Override
         public void run() {
             try {
                 in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                 //等待接收客户端发送的数据
                 while (isConnected) {

                     if ((msg = in.readLine()) != null) {

                         // 创建一个Instrumentation对象，调用inst对象的按键模拟方法
                         Instrumentation inst = new Instrumentation();
                         try{
                             int codeKey = Integer.parseInt(msg);
                             //codeKey对应键值参照KeyCodeTable.txt文件，在客户端中实现
                             inst.sendKeyDownUpSync(codeKey);

                             //发送回执
                             this.sendmsg(socket);
                         }catch(Exception ex){
                             ex.printStackTrace();
                         }

                     }
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }

         private void sendmsg(Socket socket2) {
             // TODO Auto-generated method stub
             PrintWriter pout = null;

             try {
                 pout = new PrintWriter(new BufferedWriter(
                         new OutputStreamWriter(socket2.getOutputStream())), true);
                 pout.println("I am ok");
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         }

     }

这里使用了Instrumentation()对象来模拟按键的处理，在实际使用中，效率还行，没有很严重的延时，若真有延时，感觉也是网络方面的。

使用了socket.getInputStream()与socket.getOutputStream()方法来进行socket数据的接收与发送

6.最后新开一个Handler对网络断开时进行处理，也可以监听系统网络变化的广播，有时间研究下service的生命周期

     private Handler mHandler01 = new Handler(){

         @Override
         public void handleMessage(Message msg) {
             // TODO Auto-generated method stub
             super.handleMessage(msg);
             switch(msg.what){
             //连接失败
             case 0x0001:
                 initData();
                 break;
             }
         }

     };

7.开机自启动，继承BroadcastReceiver，监听系统开机广播就ok了，记得在AndroidManifest.xml文件中声明BOOT_COMPLETED属性

 　　　　if(intent.getAction().equals("android.intent.action.BOOT_COMPLETED")){
             Intent intent2 = new Intent(context, UdpService.class);
             context.startService(intent2);
         }

8.还有一个问题，如果我们就这样直接编译，输出apk到电视中，会出现权限不足的error，原因是apk不是系统应用，只有uid为system id才可以去模拟按键事件，所以在

AndroidManifest.xml中加上android:sharedUserId="android.uid.system"，以及<uses-permission android:name="android.permission.INJECT_EVENTS" />

再编写Android.mk，最后在android源码中使用mm命令编译apk，这样就ok了。

服务器端的流程差不多是这样了，附上完整源码，包含服务器端与客户端Demo：

http://download.csdn.net/detail/u012062785/9684842

thread与runnable的区别：https://www.oschina.net/question/565065_86563