Android基于Socket无线遥控（1）--Socket基本模型搭建

按计划每周更新一篇技术博文，上周因工作忙而中断，第三篇：《Android基于Socket无线遥控（1）--Socket基本模型搭建》

    本例子内容比较多，初步构思分三篇完成，Android系统基于Socket实现无线遥控，可控制另一台Android设备音量增减、亮度调节、方向控制、确认、退出等，本篇主要介绍Socket基本模型搭建，以及无线控制Android系统音量增加，亮度增减。

一、技术介绍

1、Socket介绍

    Socket技术实现，软件实现部分有客户端（遥控器）和服务器（显示器），服务器与客户端定制一致的收发消息信息，以致达到需求功能，主要使用步骤如下：

a.服务器通过创建ServerSocket指定一个固定的端口号，以致客户端能够向该端口号发送连接请求；

b.服务器通过accept()方法为下一个传入的连接请求创建Socket实例，如果没有新的连接请求，accept()方法将处于阻塞等待；

c.客户端创建Socket，指定远程地址和端口号，向服务端发送请求；

d.客户端与服务器连接成功后通过InputStream和OutputStream进行数据信息交互以达到无线遥控功能。

    通常情况下，服务器端可能会接收多个客户端的请求，此时需要使用循环来接收来自不同客户端的连接请求，主要使用如下代码：

     

[java]  view plain copy

1. // 创建一个ServerSocket,Ports为端口号  
2.     ServerSocket ss = new ServerSocket(Ports);  
3.                //  采用循环不断接收来自客户端的请求  
4.                 while(!quit)  
5.                 {  
6.                     //此行代码会阻塞，将一直等待别人的连接  
7.                     Socket s = ss.accept();                                  
8.                     socketList.add(s);  
9.                     //每当客户端连接后启动一条ServerThread线程为该客户端服务  
10.                     new Thread(new ServerThread(s)).start();  
11.                     ……                    
12.                 }  

    客户端创建Socket，指定服务端IP地址和端口号，当Socket创建成功后，服务端的ServerSocket的accept()方法会向下执行，此时服务器端和客户端产生一对相互连接的Socket，创建Socket代码如下：

[java]  view plain copy

1.      // 创建Socket连接服务器，IP 为IP地址，Ports为端口号  
2.     Socket s = new Socket( IP, Ports );  
3.     // 客户端启动ClientThread线程不断读取来自服务器的数据  
4.     new Thread(new ClientThread(s , handler )).start();  
5. ……  

    当客户端与服务端产生对应的Socket之后，程序无需再区分服务端与客户端，而是通过各自的Socket进行通讯，主要采用Java IO流来进行数据信息传输，输入输出流方法乳如下：

a.InputStream getInputStream() 返回该Socket对象对应的输入流，让程序通过该输入流从Socket中取出数据，主要使用之一：

[java]  view plain copy

1. ……  
2.      BufferedReader br = new BufferedReader( new InputStreamReader(socket.getInputStream()));  
3. ……  
4.      String content = null;  
5.     //不断读取Socket输入流中的内容。  
6.      while ((content = br .readLine()) != null)  
7.     {  
8.       // 对接收到的信息进行对应操作  
9.      }  

b.OutputStream getOutputStream() 返回该Socket对象对应的输出流，让程序通过该输出流向Socket中输出数据，主要使用之一:

[java]  view plain copy

1. ……  
2.     OutputStream os = socket.getOutputStream();  
3.    String OutputStr = "";  
4. ……  
5.    os.write(OutputStr + "\r\n").getBytes("utf-8"));  
6. ……  

 

二、编码前预定准则

1、客户端（遥控器）、服务器（显示器）

2、端口：58888 （有效范围0~65535）

3、消息规则

a.客户端 --请求连接--> 服务器

消息："CN"     // CN为connect标志

b.客户端 --方向请求--> 服务器

消息：

"DT" // 向上（ direction  Top）

"DB" // 向下（ bottom  ）

"DL" // 向左（Left）

"DR" // 向右（Right）

 

C.客户端 --音量增加、减少-->服务器

消息:

"VO +" // 音量增加（v olume）

"VO -"  // 音量减少

 

D.客户端  --亮度增加、减少-->服务器

消息：

"BR +" // 亮度增加（ brightness）

"BR -"  // 亮度减少

 

E.客户端 --单击确认-->服务器

消息：

"CL" // 单击确认(Click)

F.客户端 --菜单-->服务器

消息：

"ME" // 取消（Menu l）

 

G.客户端 --返回--> 服务器

消息：

"BA" //退出（Back）

H.客户端 --电源--> 服务器

消息：

"PO" // 电源（Power） 

I.客户端 --Home--> 服务器

消息：

"HO" //退出（Home）

三、编码实现

 

1.页面截图

a.遥控器简单界面

 

b.服务器端显示界面一

 

c.服务器端显示界面二

 

2.客户端（遥控器）主要代码

a. RemoteControlClient.java 遥控器客户端

[java]  view plain copy

1. /** 
2.  * 遥控器客户端 
3.  * 
4.  */  
5. public class RemoteControlClient extends Activity  
6. {  
7.   
8. ……  
9.     private OutputStream os ;  
10.   
11.     private String IP = "192.168.2.10" ; // 此IP地址根据实际项目修改  
12.     private int Ports = 58888;          // 端口  
13.   
14. ……  
15.      
16.     private Handler handler = new Handler()  
17.     {  
18.         @Override  
19.         public void handleMessage(Message msg)  
20.         {  
21.             // 如果消息来自于子线程  
22.             if (msg.what == 0x123)  
23.             {  
24.                 // 将读取的内容追加显示在文本框中  
25.                 show .append(msg.obj .toString());  
26.             }  
27.         }  
28.     };  
29.   
30.     OnClickListener mOnClickListener = new OnClickListener()  
31.     {  
32.         @Override  
33.         public void onClick(View v)  
34.         {  
35.             switch (v.getId()) {  
36.                 case R.id. send:  
37.                     try  
38.                     {  
39.                         Log. v( "", "Socket ---> input : " + input.getText().toString());  
40.                         // 将用户在文本框内输入的内容写入网络  
41.                         os .write((input .getText().toString() + "\r\n").getBytes( "utf-8" ));  
42.                         // 清空input文本框  
43.                         input .setText("" );  
44.                     }  
45.                     catch (Exception e)  
46.                     {  
47.                         e.printStackTrace();  
48.                     }  
49.   
50.                     break ;  
51.   
52.                 case R.id. volume_add_btn:  
53.                     input .setText("VO +" );                    
54.                     break ;  
55.   
56.                 case R.id. volume_reduced_btn:  
57.                     input .setText("VO -" );  
58.                     break ;  
59.                 case R.id. brightness_add_btn:  
60.                     input .setText("BR +" );  
61.                     break ;  
62.                 case R.id. brightness_reduced_btn:  
63.                     input .setText("BR -" );                     
64.                     break ;  
65.                 case R.id. direction_top_btn:  
66.                     input .setText("DT" );  
67.                     break ;  
68.                 case R.id. direction_bottom_btn:  
69.                     input .setText("DB" );  
70.                     break ;  
71.                 case R.id. direction_left_btn:  
72.                     input .setText("DL" );  
73.                     break ;  
74.   
75.                 case R.id. direction_right_btn:  
76.                     input .setText("DR" );  
77.                     break ;  
78.                 case R.id. click_btn:  
79.                     input .setText("CL" );  
80.                     break ;  
81.                 case R.id. back_btn:  
82.                     input .setText("BA" );  
83.                     break ;  
84.                 case R.id. menu_btn:  
85.                     input .setText("ME" );                     
86.                     break ;  
87.                 case R.id. power_btn:  
88.                     input .setText("PO" );                     
89.                     break ;  
90.                 case R.id. home_btn:  
91.                     input .setText("HO" );                     
92.                     break ;  
93.                      
94.                 case R.id. connect_btn:  
95.                                 
96.                     try  
97.                     {  
98.                         IP = ipInput .getText().toString();  
99.                         Log. v( "", " --> IP : " + IP );  
100.                         // 创建Socket连接服务器  
101.                         Socket s = new Socket(IP , Ports);  
102.                         // 客户端启动ClientThread线程不断读取来自服务器的数据  
103.                         new Thread( new ClientThread(s, handler)).start();                         os = s.getOutputStream();  
104.                          
105.                         Toast. makeText( context, getString(R.string. con_success ), Toast. LENGTH_LONG).show();  
106.                         reContentView();  
107.                          
108.                     }  
109.                     catch (Exception e)  
110.                     {  
111.                         e.printStackTrace();  
112.                         Toast. makeText( context, getString(R.string. con_failed ), Toast. LENGTH_LONG).show();  
113.                     }  
114.                     break ;  
115.             }  
116.         }  
117.     };  
118. }  

b. ClientThread.java 不断读取来自服务端的数据信息

 

[java]  view plain copy

1. public class ClientThread implements Runnable  
2. {  
3.  //该线程负责处理的Socket  
4.  private Socket s;  
5.  private Handler handler;  
6.  //该线程所处理的Socket所对应的输入流  
7.  BufferedReader br = null;  
8.  public ClientThread(Socket s , Handler handler)  
9.   throws IOException  
10.  {  
11.   this.s = s;  
12.   this.handler = handler;  
13.   br = new BufferedReader(new InputStreamReader(s.getInputStream()));  
14.  }  
15.   
16.  public void run()  
17.  {  
18.   try  
19.   {  
20.    String content = null;  
21.    //不断读取Socket输入流中的内容。  
22.    while ((content = br.readLine()) != null)  
23.    {  
24.     // 每当读到来自服务器的数据之后，发送消息通知程序界面显示该数据  
25.     Message msg = new Message();  
26.     msg.what = 0x123;  
27.     msg.obj = content;  
28.     handler.sendMessage(msg);  
29.    }  
30.   }  
31.   catch (Exception e)  
32.   {  
33.    e.printStackTrace();  
34.   }  
35.  }  
36. }  

 

c.Manifest.xml(配置文件)需要添加权限

[html]  view plain copy

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

3.服务端（显示器）主要代码（ps. 部分功能未完成，下篇更新）

a.MainActivity.java 服务端（显示器）

[java]  view plain copy

1. public class MainActivity extends Activity {  
2.   
3.     private Button getIpBtn;  
4.     private static TextView showTips;  
5.     private TextView showIp;  
6.     private WifiAdmin wifi;  
7.     public static MainActivity mActivity;  
8.     private ToggleButton startTB;  
9.     private Intent mIntent;  
10.     private int ip;  
11.     public static SystemManager systemManager = null;      
12.   
13.     public static final int CONN_SUCCESS = 1;  
14.     public static final int CONN_ERROR = 2;  
15.     public static final int SET_BRIGHTNESS = 3;  
16.   
17.   
18.     @Override  
19.     public void onCreate(Bundle savedInstanceState) {  
20.         super.onCreate(savedInstanceState);  
21.         setContentView(R.layout.activity_main);  
22.         mActivity = this;  
23.         wifi = new WifiAdmin(getApplicationContext());  
24.         ip = wifi.GetIPAddress();  
25.   
26.         systemManager = new SystemManager();  
27.   
28.         mIntent = new Intent();  
29.         mIntent.setAction("com.example.socket.SERVICE");  
30.   
31.         getIpBtn = (Button)findViewById(R.id.get_ip_btn);  
32.         showTips = (TextView)findViewById(R.id.tips_tv);  
33.         showIp = (TextView)findViewById(R.id.ip_tv);  
34.         startTB = (ToggleButton)findViewById(R.id.socketStart);          
35.   
36.         getIpBtn.setOnClickListener(mOnClickListener);  
37.   
38.         startTB.setOnCheckedChangeListener(mOnCheckedChangeListener);      
39.   
40.     }  
41.   
42.     private OnClickListener mOnClickListener = new OnClickListener() {  
43.   
44.         @Override  
45.         public void onClick(View v) {  
46.             if(v == getIpBtn){  
47.                 ip = wifi.GetIPAddress();  
48.                 String IP = WifiAdmin.longToIP(ip);  
49.                 showIp.setText("IP : " + IP);  
50.   
51.             }  
52.         }  
53.     };  
54.   
55.     // 连接 & 断开 Socket服务  
56.     private OnCheckedChangeListener mOnCheckedChangeListener = new OnCheckedChangeListener() {  
57.         @Override  
58.         public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {  
59.   
60.             if(buttonView == startTB){  
61.                 if(isChecked){  
62.                     startService(mIntent);  
63.                 }else{  
64.                     stopService(mIntent);  
65.                     mHandler.sendEmptyMessage(CONN_ERROR);  
66.                 }  
67.             }  
68.         }  
69.     };  
70.   
71.     public static Handler mHandler = new Handler(){  
72.   
73.         @Override  
74.         public void handleMessage(Message msg) {  
75.             super.handleMessage(msg);  
76.   
77.             switch (msg.what) {  
78.                 case CONN_SUCCESS:  
79.                     String socketListStr="";  
80.                     int num = 1;  
81.                     for(Socket socket : SocketService.socketList)  
82.                     {  
83.                         socketListStr += "\n------------------\n客户端 " + num++ + " : " +socket;  
84.                     }  
85.   
86.                     showTips.setText( mActivity.getString(R.string.tips_conn_success) + socketListStr);  
87.                     break;  
88.   
89.                 case CONN_ERROR:  
90.                     showTips.setText(R.string.tips_conn_wifi);  
91.                     break;  
92.   
93.                 case SET_BRIGHTNESS:  
94.                     float brightness = (Float) msg.obj;  
95.                     SystemManager.setBrightness(MainActivity.mActivity,brightness);                      
96.                     SystemManager.saveBrightness(MainActivity.mActivity.getContentResolver(),brightness);  
97.   
98.                     break;  
99.             }  
100.         }  
101.   
102.     };  
103. }  

b.SocketService.java 服务端创建SocketService不断接收客户端连接请求

 

[java]  view plain copy

1. /** 
2.  * 负责接收新的连接 
3.  * 以及控制系统的功能 
4.  * @author zzp 
5.  * 
6.  */  
7. public class SocketService extends Service {  
8.     //定义保存所有Socket的ArrayList  
9.     public static ArrayList<Socket> socketList = new ArrayList<Socket>();  
10.     private boolean quit = false;  
11.     private ServerSocket ss;  
12.     private int Ports = 58888;          // 端口  
13.     private static SocketService mService;  
14.   
15.     @Override  
16.     public IBinder onBind(Intent intent) {  
17.         // TODO Auto-generated method stub  
18.         return null;  
19.     }  
20.   
21.     @Override  
22.     public void onCreate() {  
23.         super.onCreate();  
24.   
25.         Log.v("", "SocketService onCreate");  
26.         mService = this;  
27.         new Thread(mSocketRunnable).start();  
28.   
29.     }  
30.   
31.     /** 
32.      * 此线程等待新的客户端加入 
33.      */  
34.     Runnable mSocketRunnable = new Runnable() {          
35.         @Override  
36.         public void run() {  
37.   
38.             try {  
39.                 ss = new ServerSocket(Ports);  
40.   
41.                 while(!quit)  
42.                 {  
43.                     //此行代码会阻塞，将一直等待别人的连接  
44.                     Socket s = ss.accept();  
45.                     Log.v("", "Socket ---> s : " + s.toString());                      
46.                     socketList.add(s);  
47.                     //每当客户端连接后启动一条ServerThread线程为该客户端服务  
48.                     new Thread(new ServerThread(s)).start();  
49.   
50.                     MainActivity.mHandler.sendEmptyMessage(MainActivity.CONN_SUCCESS);  
51.                 }  
52.             } catch (IOException e) {  
53.                 e.printStackTrace();  
54.             } catch (Exception e){  
55.                 e.printStackTrace();  
56.             }  
57.   
58.         }  
59.     };  
60.   
61.     @Override  
62.     public void onDestroy() {  
63.         super.onDestroy();  
64.         quit = true;  
65.         SocketService.socketList.clear();  
66.   
67.         try {  
68.             ss.close();  
69.         } catch (IOException e) {  
70.             // TODO Auto-generated catch block  
71.             e.printStackTrace();  
72.         }  
73.         Log.v("", "SocketService onDestroy");  
74.     }  
75.   
76.     public static final int SET_BRIGHTNESS = 1;  
77.   
78.     public static Handler mHandler = new Handler(){  
79.   
80.         @Override  
81.         public void handleMessage(Message msg) {  
82.             super.handleMessage(msg);  
83.   
84.             switch (msg.what) {  
85.                 case SET_BRIGHTNESS:  
86.                     // 取得当前运行的Activity名字  
87.                     ActivityManager am = (ActivityManager)mService.getSystemService(ACTIVITY_SERVICE);  
88.                     ComponentName cn = am.getRunningTasks(1).get(0).topActivity;  
89.   
90.                     Log.d("", "pkg:"+cn.getPackageName());  
91.                     Log.d("", "cls:"+cn.getClassName());  
92.                     Log.d("", "MainActivity.class.getName():"+MainActivity.class.getName());  
93.   
94.                     if(!(cn.getClassName()).endsWith(MainActivity.class.getName())){  
95.                         Intent i = new Intent();  
96.                         i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
97.                         i.setClass(mService, MainActivity.class);  
98.                         mService.startActivity(i);  
99.                     }  
100.   
101.                     float brightness = (Float) msg.obj;  
102.                     SystemManager.setBrightness(MainActivity.mActivity,brightness);                      
103.                     SystemManager.saveBrightness(MainActivity.mActivity.getContentResolver(),brightness);  
104.   
105.                     break;  
106.             }  
107.         }  
108.     };  
109. }  

d.ServerThread.java 主要负责服务端接收客户端的信息，并分配相应操作（未完成）

[java]  view plain copy

1. /** 
2.  * 负责处理每个线程通信的线程类 
3.  * 
4.  */  
5. public class ServerThread implements Runnable   
6. {  
7.     //定义当前线程所处理的Socket  
8.     Socket s = null;  
9.     //该线程所处理的Socket所对应的输入流  
10.     BufferedReader br = null;  
11.   
12.      /** 
13.      * 连接请求 
14.      */  
15.     public static final String OPERATION_CONNECT = "CN";  
16.       
17.     /** 
18.      * 方向 
19.      */  
20.     public static final String OPERATION_DIRECTION_TOP = "DT";  
21.     public static final String OPERATION_DIRECTION_BOTTOM = "DB";  
22.     public static final String OPERATION_DIRECTION_LEFT = "DL";  
23.     public static final String OPERATION_DIRECTION_RIGHT = "DR";  
24.       
25.     /** 
26.      * 音量 
27.      */  
28.     public static final String OPERATION_VOLUME = "VO";  
29.       
30.     /** 
31.      * 亮度 
32.      */  
33.     public static final String OPERATION_BRIGHTNESS = "BR";  
34.       
35.     /** 
36.      * 单击&确认 
37.      */  
38.     public static final String OPERATION_CLICK = "CL";  
39.       
40.     /** 
41.      * 菜单 
42.      */  
43.     public static final String OPERATION_MENU = "ME";  
44.       
45.     /** 
46.      * 返回 
47.      */  
48.     public static final String OPERATION_BACK = "BA";  
49.       
50.     /** 
51.      * 电源 
52.      */  
53.     public static final String OPERATION_POWER = "PO";  
54.       
55.     /** 
56.      * Home 
57.      */  
58.     public static final String OPERATION_HOME = "HO";  
59.       
60.       
61.     public ServerThread(Socket s)  
62.         throws IOException  
63.     {  
64.         this.s = s;  
65.         //初始化该Socket对应的输入流  
66.         br = new BufferedReader(new InputStreamReader(s.getInputStream() , "utf-8"));   //②  
67.           
68.     }  
69.   
70.     /** 
71.      * 向所有接入客户端发信息 sendMessageToClient 
72.      */  
73.     public synchronized static void sendMessageToClient(String msg){  
74.         Log.v("", "sendMessageToClient --> : " + msg);  
75.           
76.         //遍历socketList中的每个Socket，  
77.         //将读到的内容向每个Socket发送一次  
78.         for (Socket s : SocketService.socketList)  
79.         {  
80.             try {  
81.                 OutputStream os = s.getOutputStream();  
82.                 os.write((msg + "\n").getBytes("utf-8"));  
83.             } catch (IOException e) {  
84.                 e.printStackTrace();  
85.                 Log.e("", " --> sendMessageToClient error <-- 删除该Socket : " + s);  
86.                 //删除该Socket。  
87.                 SocketService.socketList.remove(s);    //①  
88.             }  
89.         }  
90.     }  
91.       
92.     /** 
93.      * 此线程不断接收客户端发过来的请求信息 
94.      */  
95.     public void run()  
96.     {  
97.         try  
98.         {  
99.             String content = null;  
100.             //采用循环不断从Socket中读取客户端发送过来的数据  
101.             while ((content = readFromClient()) != null)  
102.             {  
103.   
104.                 if(content.length() < 2) continue;  // 避免发送空指令 或错误指令导致异常  
105.                   
106.                 String requestStr = content.substring(0, 2);  
107.                 Log.v("", "SocketServer ---> content : " + content + "   , requestStr : " + requestStr );  
108.                   
109.                 if(requestStr.endsWith(OPERATION_VOLUME)){  
110.                     MainActivity.systemManager.CtrlVolume(content);  
111.                 }else if(requestStr.endsWith(OPERATION_BRIGHTNESS)){  
112.                     MainActivity.systemManager.CtrlBrightness(content);  
113.                 }  
114.                   
115.                 // TODO 未完成，下篇完成  
116.   
117.             }  
118.         }  
119.         catch (Exception e)  
120.         {  
121.             e.printStackTrace();  
122.         }  
123.     }  
124.       
125.       
126.     /** 
127.      * 定义读取客户端数据的方法 
128.      * @return 接收到的请求信息 
129.      */  
130.     private String readFromClient()  
131.     {  
132.         try  
133.         {  
134.             return br.readLine();     
135.         }  
136.         //如果捕捉到异常，表明该Socket对应的客户端已经关闭  
137.         catch (IOException e)  
138.         {  
139.             //删除该Socket。  
140.             SocketService.socketList.remove(s);      
141.             MainActivity.mHandler.sendEmptyMessage(MainActivity.CONN_ERROR);  
142.         }  
143.         return null;  
144.     }  
145. }  

e.SystemManager.java 操作功能实现类，控制系统音量、系统亮度等（未完成）

[java]  view plain copy

1. /** 
2.  * 控制系统的逻辑类 
3.  * @author zzp 
4.  * 
5.  */  
6. public class SystemManager {  
7.     private AudioManager audioManager;  
8.     private Activity mActivity;  
9.     private static int brightnessNum = 2;  
10.           
11.     public SystemManager(){  
12.         mActivity = MainActivity.mActivity;  
13.         audioManager = (AudioManager)mActivity.getSystemService(Context.AUDIO_SERVICE);         
14.           
15.         getScreenBrightness(mActivity);  
16.         brightnessNum = (int)((getScreenBrightness(mActivity)*1.0/255) * 5) ;  
17.         Log.v("", "---> getScreenBrightness(mActivity) : " + getScreenBrightness(mActivity));  
18.         Log.v("", "--->  brightnessNum : " + brightnessNum);  
19.     }  
20.   
21.     /** 
22.      * 媒体音量增减 
23.      */  
24.     public void CtrlVolume(String ctrlCode){  
25.   
26.         if(ctrlCode.contains("-")){  
27.             //第一个参数：声音类型  
28.             //第二个参数：调整音量的方向  
29.             //第三个参数：可选的标志位  
30.             audioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC,   
31.                     AudioManager.ADJUST_LOWER,   
32.                     AudioManager.FLAG_SHOW_UI);  
33.         }else{  
34.             audioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC,   
35.                     AudioManager.ADJUST_RAISE,   
36.                     AudioManager.FLAG_SHOW_UI);    //调高声音  
37.         }  
38.     }  
39.   
40.   
41.     /** 
42.      * 系统亮度增减 
43.      */  
44.     public void CtrlBrightness(String ctrlCode){  
45.         if(brightnessNum < 0 || brightnessNum > 5) brightnessNum = 2;  
46.   
47.         if(ctrlCode.contains("-")){  
48.             if(brightnessNum > 0) brightnessNum--;              
49.         }else{  
50.             if(brightnessNum < 5) brightnessNum++;  
51.         }  
52.   
53.         Message msg = new Message();  
54.         msg.what = SocketService.SET_BRIGHTNESS;  
55.         msg.obj = (brightnessNum)*1.0f/5;  
56.         SocketService.mHandler.sendMessage(msg);  
57.     }  
58.   
59.     /** 
60.      * 获取屏幕的亮度 
61.      *  
62.      * @param activity 
63.      * @return 
64.      */  
65.     public static int getScreenBrightness(Activity activity) {  
66.         int nowBrightnessValue = 0;  
67.         ContentResolver resolver = activity.getContentResolver();  
68.         try {  
69.             nowBrightnessValue = android.provider.Settings.System.getInt(  
70.                     resolver, Settings.System.SCREEN_BRIGHTNESS);  
71.         } catch (Exception e) {  
72.             e.printStackTrace();  
73.         }  
74.         return nowBrightnessValue;  
75.     }  
76.   
77.     /** 
78.      * 设置系统亮度 
79.      * @param brightness : 0~1 
80.      */  
81.     public static void setBrightness(Activity activity, float brightness)   
82.     {  
83.         WindowManager.LayoutParams  lp = activity.getWindow().getAttributes();  
84.         lp.screenBrightness = brightness; //这里设置范围 0~1.0  
85.         activity.getWindow().setAttributes(lp);  
86.   
87.         Settings.System.putInt(activity.getContentResolver(),  
88.                 android.provider.Settings.System.SCREEN_BRIGHTNESS,  
89.                 (int)(brightness*255));  
90.     }  
91.       
92.     /** 
93.      * 保存亮度设置状态 
94.      *  
95.      * @param resolver 
96.      * @param brightness : 0~1 
97.      */  
98.     public static void saveBrightness(ContentResolver resolver, float brightness) {  
99.         Uri uri = android.provider.Settings.System  
100.                 .getUriFor("screen_brightness");  
101.         android.provider.Settings.System.putInt(resolver, "screen_brightness",  
102.                 (int)(brightness*255));  
103.    
104.         resolver.notifyChange(uri, null);  
105.     }  
106.       
107.       
108. }  

f.WifiAdmin.java 与wifi相关类，可查询本机Wifi连接状态、IP地址、IP地址的int形式与IP显示形式转换

[java]  view plain copy

1. /** 
2.  *  与wifi相关 
3.  */  
4. public class WifiAdmin    
5. {    
6.     //定义WifiManager对象    
7.     private WifiManager mWifiManager;    
8.     //定义WifiInfo对象    
9.     private WifiInfo mWifiInfo;    
10.     //扫描出的网络连接列表    
11.     private List<ScanResult> mWifiList;    
12.     //网络连接列表    
13.     private List<WifiConfiguration> mWifiConfiguration;    
14.     //定义一个WifiLock    
15.     WifiLock mWifiLock;    
16.     //构造器    
17.     public  WifiAdmin(Context context)    
18.     {    
19.         //取得WifiManager对象    
20.         mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);    
21.         //取得WifiInfo对象    
22.         mWifiInfo = mWifiManager.getConnectionInfo();    
23.     }    
24.     //打开WIFI    
25.     public void OpenWifi()    
26.     {    
27.         if (!mWifiManager.isWifiEnabled())    
28.         {    
29.             mWifiManager.setWifiEnabled(true);    
30.   
31.         }    
32.     }    
33.     //关闭WIFI    
34.     public void CloseWifi()    
35.     {    
36.         if (!mWifiManager.isWifiEnabled())    
37.         {    
38.             mWifiManager.setWifiEnabled(false);     
39.         }    
40.     }    
41.     //锁定WifiLock    
42.     public void AcquireWifiLock()    
43.     {    
44.         mWifiLock.acquire();    
45.     }    
46.     //解锁WifiLock    
47.     public void ReleaseWifiLock()    
48.     {    
49.         //判断时候锁定    
50.         if (mWifiLock.isHeld())    
51.         {    
52.             mWifiLock.acquire();    
53.         }    
54.     }    
55.     //创建一个WifiLock    
56.     public void CreatWifiLock()    
57.     {    
58.         mWifiLock = mWifiManager.createWifiLock("Test");    
59.     }    
60.     //得到配置好的网络    
61.     public List<WifiConfiguration> GetConfiguration()    
62.     {    
63.         return mWifiConfiguration;    
64.     }    
65.     //指定配置好的网络进行连接    
66.     public void ConnectConfiguration(int index)    
67.     {    
68.         //索引大于配置好的网络索引返回    
69.         if(index > mWifiConfiguration.size())    
70.         {    
71.             return;    
72.         }    
73.         //连接配置好的指定ID的网络    
74.         mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId, true);    
75.     }    
76.     public void StartScan()    
77.     {    
78.         mWifiManager.startScan();    
79.         //得到扫描结果    
80.         mWifiList = mWifiManager.getScanResults();    
81.         //得到配置好的网络连接    
82.         mWifiConfiguration = mWifiManager.getConfiguredNetworks();    
83.     }    
84.     //得到网络列表    
85.     public List<ScanResult> GetWifiList()    
86.     {    
87.         return mWifiList;    
88.     }    
89.     //查看扫描结果    
90.     public StringBuilder LookUpScan()    
91.     {    
92.         StringBuilder stringBuilder = new StringBuilder();    
93.         for (int i = 0; i < mWifiList.size(); i++)    
94.         {    
95.             stringBuilder.append("Index_"+new Integer(i + 1).toString() + ":");    
96.             //将ScanResult信息转换成一个字符串包    
97.             //其中把包括：BSSID、SSID、capabilities、frequency、level    
98.             stringBuilder.append((mWifiList.get(i)).toString());    
99.             stringBuilder.append("/n");    
100.         }    
101.         return stringBuilder;    
102.     }    
103.     //得到MAC地址    
104.     public String GetMacAddress()    
105.     {    
106.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();    
107.     }    
108.     //得到接入点的BSSID    
109.     public String GetBSSID()    
110.     {    
111.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();    
112.     }    
113.     //得到IP地址    
114.     public int GetIPAddress()    
115.     {    
116.         return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();    
117.     }    
118.     //得到连接的ID    
119.     public int GetNetworkId()    
120.     {    
121.         return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();    
122.     }    
123.     //得到WifiInfo的所有信息包    
124.     public String GetWifiInfo()    
125.     {    
126.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();    
127.   
128.     }    
129.     //添加一个网络并连接    
130.     public void AddNetwork(WifiConfiguration wcg)    
131.     {    
132.         int wcgID = mWifiManager.addNetwork(wcg);     
133.         mWifiManager.enableNetwork(wcgID, true);     
134.     }    
135.     //断开指定ID的网络    
136.     public void DisconnectWifi(int netId)    
137.     {    
138.         mWifiManager.disableNetwork(netId);    
139.         mWifiManager.disconnect();    
140.     }  
141.   
142.     //将127.0.0.1形式的IP地址转换成十进制整数，这里没有进行任何错误处理  
143.     public static long ipToLong(String strIp){  
144.         long[] ip = new long[4];  
145.         //先找到IP地址字符串中.的位置  
146.         int position1 = strIp.indexOf(".");  
147.         int position2 = strIp.indexOf(".", position1 + 1);  
148.         int position3 = strIp.indexOf(".", position2 + 1);  
149.         //将每个.之间的字符串转换成整型  
150.         ip[0] = Long.parseLong(strIp.substring(0, position1));  
151.         ip[1] = Long.parseLong(strIp.substring(position1+1, position2));  
152.         ip[2] = Long.parseLong(strIp.substring(position2+1, position3));  
153.         ip[3] = Long.parseLong(strIp.substring(position3+1));  
154.         return (ip[3] << 24) + (ip[2] << 16) + (ip[1] <<  8 ) + ip[0];  
155.     }  
156.   
157.     //将十进制整数形式转换成127.0.0.1形式的ip地址  
158.     public static String longToIP(long longIp){  
159.         StringBuffer sb = new StringBuffer("");  
160.         //将高24位置0  
161.         sb.append(String.valueOf((longIp & 0x000000FF)));  
162.         sb.append(".");  
163.         //将高16位置0，然后右移8位  
164.         sb.append(String.valueOf((longIp & 0x0000FFFF) >>>  8 ));  
165.         sb.append(".");  
166.         //将高8位置0，然后右移16位  
167.         sb.append(String.valueOf((longIp & 0x00FFFFFF) >>> 16));  
168.         sb.append(".");  
169.         //直接右移24位  
170.         sb.append(String.valueOf((longIp >>> 24)));  
171.         return sb.toString();  
172.     }  
173. }    

g.Manifest.xml(配置文件)需要添加权限

[html]  view plain copy

1. <uses-permission android:name="android.permission.INTERNET" />  
2. <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />  
3. <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />  
4. <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />  
5. <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />  
6. <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />  
7. <uses-permission android:name="android.permission.WRITE_SETTINGS" />  
8. <uses-permission android:name="android.permission.GET_TASKS" />  

四、后记&下篇内容

    本例中设置系统亮度未能很好的实现，每次设置亮度都会进行判断当前系统显示的Activty，而设置亮度目前需要到服务端界面设置才成功，所以退出服务端界面后，设置系统亮度会进行判断，如果当前不是显示服务端MainActivity，则在服务中重新打开。

    下篇主要内容是模拟系统按键消息，单击事件，滚动事件等。

 

 

参考引用：

1.《李刚疯狂Android讲义》十三章

2.Android APIs： http://developer.android.com/reference/java/net/ServerSocket.html