按计划每周更新一篇技术博文，上周因工作忙而中断，第三篇：《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. ServerSocketss=newServerSocket(Ports);
3. //采用循环不断接收来自客户端的请求
4. while(!quit)
5. {
6. //此行代码会阻塞，将一直等待别人的连接
7. Sockets=ss.accept();
8. socketList.add(s);
9. //每当客户端连接后启动一条ServerThread线程为该客户端服务
10. newThread(newServerThread(s)).start();
11. ……
12. }

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

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

当客户端与服务端产生对应的Socket之后，程序无需再区分服务端与客户端，而是通过各自的Socket进行通讯，主要采用Java IO流来进行数据信息传输，输入输出流方法乳如下： a.InputStream getInputStream() 返回该Socket对象对应的输入流，让程序通过该输入流从Socket中取出数据，主要使用之一： [java] view plain copy

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

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

1. ……
2. OutputStreamos=socket.getOutputStream();
3. StringOutputStr="";
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. publicclassRemoteControlClientextendsActivity
6. {
8. ……
9. privateOutputStreamos;
11. privateStringIP="192.168.2.10";//此IP地址根据实际项目修改
12. privateintPorts=58888;//端口
14. ……
16. privateHandlerhandler=newHandler()
17. {
18. @Override
19. publicvoidhandleMessage(Messagemsg)
20. {
21. //如果消息来自于子线程
22. if(msg.what==0x123)
23. {
24. //将读取的内容追加显示在文本框中
25. show.append(msg.obj.toString());
26. }
27. }
28. };
30. OnClickListenermOnClickListener=newOnClickListener()
31. {
32. @Override
33. publicvoidonClick(Viewv)
34. {
35. switch(v.getId()){
36. caseR.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(Exceptione)
46. {
47. e.printStackTrace();
48. }
50. break;
52. caseR.id.volume_add_btn:
53. input.setText("VO+");
54. break;
56. caseR.id.volume_reduced_btn:
57. input.setText("VO-");
58. break;
59. caseR.id.brightness_add_btn:
60. input.setText("BR+");
61. break;
62. caseR.id.brightness_reduced_btn:
63. input.setText("BR-");
64. break;
65. caseR.id.direction_top_btn:
66. input.setText("DT");
67. break;
68. caseR.id.direction_bottom_btn:
69. input.setText("DB");
70. break;
71. caseR.id.direction_left_btn:
72. input.setText("DL");
73. break;
75. caseR.id.direction_right_btn:
76. input.setText("DR");
77. break;
78. caseR.id.click_btn:
79. input.setText("CL");
80. break;
81. caseR.id.back_btn:
82. input.setText("BA");
83. break;
84. caseR.id.menu_btn:
85. input.setText("ME");
86. break;
87. caseR.id.power_btn:
88. input.setText("PO");
89. break;
90. caseR.id.home_btn:
91. input.setText("HO");
92. break;
94. caseR.id.connect_btn:
96. try
97. {
98. IP=ipInput.getText().toString();
99. Log.v("","-->IP:"+IP);
100. //创建Socket连接服务器
101. Sockets=newSocket(IP,Ports);
102. //客户端启动ClientThread线程不断读取来自服务器的数据
103. newThread(newClientThread(s,handler)).start();os=s.getOutputStream();
105. Toast.makeText(context,getString(R.string.con_success),Toast.LENGTH_LONG).show();
106. reContentView();
108. }
109. catch(Exceptione)
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. publicclassClientThreadimplementsRunnable
2. {
3. //该线程负责处理的Socket
4. privateSockets;
5. privateHandlerhandler;
6. //该线程所处理的Socket所对应的输入流
7. BufferedReaderbr=null;
8. publicClientThread(Sockets,Handlerhandler)
9. throwsIOException
10. {
11. this.s=s;
12. this.handler=handler;
13. br=newBufferedReader(newInputStreamReader(s.getInputStream()));
14. }
16. publicvoidrun()
17. {
18. try
19. {
20. Stringcontent=null;
21. //不断读取Socket输入流中的内容。
22. while((content=br.readLine())!=null)
23. {
24. //每当读到来自服务器的数据之后，发送消息通知程序界面显示该数据
25. Messagemsg=newMessage();
26. msg.what=0x123;
27. msg.obj=content;
28. handler.sendMessage(msg);
29. }
30. }
31. catch(Exceptione)
32. {
33. e.printStackTrace();
34. }
35. }
36. }

c.Manifest.xml(配置文件)需要添加权限 [html] view plain copy

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

3.服务端（显示器）主要代码（ps. 部分功能未完成，下篇更新） a.MainActivity.java 服务端（显示器） [java] view plain copy

1. publicclassMainActivityextendsActivity{
3. privateButtongetIpBtn;
4. privatestaticTextViewshowTips;
5. privateTextViewshowIp;
6. privateWifiAdminwifi;
7. publicstaticMainActivitymActivity;
8. privateToggleButtonstartTB;
9. privateIntentmIntent;
10. privateintip;
11. publicstaticSystemManagersystemManager=null;
13. publicstaticfinalintCONN_SUCCESS=1;
14. publicstaticfinalintCONN_ERROR=2;
15. publicstaticfinalintSET_BRIGHTNESS=3;
18. @Override
19. publicvoidonCreate(BundlesavedInstanceState){
20. super.onCreate(savedInstanceState);
21. setContentView(R.layout.activity_main);
22. mActivity=this;
23. wifi=newWifiAdmin(getApplicationContext());
24. ip=wifi.GetIPAddress();
26. systemManager=newSystemManager();
28. mIntent=newIntent();
29. mIntent.setAction("com.example.socket.SERVICE");
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);
36. getIpBtn.setOnClickListener(mOnClickListener);
38. startTB.setOnCheckedChangeListener(mOnCheckedChangeListener);
40. }
42. privateOnClickListenermOnClickListener=newOnClickListener(){
44. @Override
45. publicvoidonClick(Viewv){
46. if(v==getIpBtn){
47. ip=wifi.GetIPAddress();
48. StringIP=WifiAdmin.longToIP(ip);
49. showIp.setText("IP:"+IP);
51. }
52. }
53. };
55. //连接&断开Socket服务
56. privateOnCheckedChangeListenermOnCheckedChangeListener=newOnCheckedChangeListener(){
57. @Override
58. publicvoidonCheckedChanged(CompoundButtonbuttonView,booleanisChecked){
60. if(buttonView==startTB){
61. if(isChecked){
62. startService(mIntent);
63. }else{
64. stopService(mIntent);
65. mHandler.sendEmptyMessage(CONN_ERROR);
66. }
67. }
68. }
69. };
71. publicstaticHandlermHandler=newHandler(){
73. @Override
74. publicvoidhandleMessage(Messagemsg){
75. super.handleMessage(msg);
77. switch(msg.what){
78. caseCONN_SUCCESS:
79. StringsocketListStr="";
80. intnum=1;
81. for(Socketsocket:SocketService.socketList)
82. {
83. socketListStr+="\n------------------\n客户端"+num+++":"+socket;
84. }
86. showTips.setText(mActivity.getString(R.string.tips_conn_success)+socketListStr);
87. break;
89. caseCONN_ERROR:
90. showTips.setText(R.string.tips_conn_wifi);
91. break;
93. caseSET_BRIGHTNESS:
94. floatbrightness=(Float)msg.obj;
95. SystemManager.setBrightness(MainActivity.mActivity,brightness);
96. SystemManager.saveBrightness(MainActivity.mActivity.getContentResolver(),brightness);
98. break;
99. }
100. }
102. };
103. }

b.SocketService.java 服务端创建SocketService不断接收客户端连接请求 [java] view plain copy

1. /**
2. *负责接收新的连接
3. *以及控制系统的功能
4. *@authorzzp
5. *
6. */
7. publicclassSocketServiceextendsService{
8. //定义保存所有Socket的ArrayList
9. publicstaticArrayList<Socket>socketList=newArrayList<Socket>();
10. privatebooleanquit=false;
11. privateServerSocketss;
12. privateintPorts=58888;//端口
13. privatestaticSocketServicemService;
15. @Override
16. publicIBinderonBind(Intentintent){
17. //TODOAuto-generatedmethodstub
18. returnnull;
19. }
21. @Override
22. publicvoidonCreate(){
23. super.onCreate();
25. Log.v("","SocketServiceonCreate");
26. mService=this;
27. newThread(mSocketRunnable).start();
29. }
31. /**
32. *此线程等待新的客户端加入
33. */
34. RunnablemSocketRunnable=newRunnable(){
35. @Override
36. publicvoidrun(){
38. try{
39. ss=newServerSocket(Ports);
41. while(!quit)
42. {
43. //此行代码会阻塞，将一直等待别人的连接
44. Sockets=ss.accept();
45. Log.v("","Socket--->s:"+s.toString());
46. socketList.add(s);
47. //每当客户端连接后启动一条ServerThread线程为该客户端服务
48. newThread(newServerThread(s)).start();
50. MainActivity.mHandler.sendEmptyMessage(MainActivity.CONN_SUCCESS);
51. }
52. }catch(IOExceptione){
53. e.printStackTrace();
54. }catch(Exceptione){
55. e.printStackTrace();
56. }
58. }
59. };
61. @Override
62. publicvoidonDestroy(){
63. super.onDestroy();
64. quit=true;
65. SocketService.socketList.clear();
67. try{
68. ss.close();
69. }catch(IOExceptione){
70. //TODOAuto-generatedcatchblock
71. e.printStackTrace();
72. }
73. Log.v("","SocketServiceonDestroy");
74. }
76. publicstaticfinalintSET_BRIGHTNESS=1;
78. publicstaticHandlermHandler=newHandler(){
80. @Override
81. publicvoidhandleMessage(Messagemsg){
82. super.handleMessage(msg);
84. switch(msg.what){
85. caseSET_BRIGHTNESS:
86. //取得当前运行的Activity名字
87. ActivityManageram=(ActivityManager)mService.getSystemService(ACTIVITY_SERVICE);
88. ComponentNamecn=am.getRunningTasks(1).get(0).topActivity;
90. Log.d("","pkg:"+cn.getPackageName());
91. Log.d("","cls:"+cn.getClassName());
92. Log.d("","MainActivity.class.getName():"+MainActivity.class.getName());
94. if(!(cn.getClassName()).endsWith(MainActivity.class.getName())){
95. Intenti=newIntent();
96. i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
97. i.setClass(mService,MainActivity.class);
98. mService.startActivity(i);
99. }
101. floatbrightness=(Float)msg.obj;
102. SystemManager.setBrightness(MainActivity.mActivity,brightness);
103. SystemManager.saveBrightness(MainActivity.mActivity.getContentResolver(),brightness);
105. break;
106. }
107. }
108. };
109. }

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

1. /**
2. *负责处理每个线程通信的线程类
3. *
4. */
5. publicclassServerThreadimplementsRunnable
6. {
7. //定义当前线程所处理的Socket
8. Sockets=null;
9. //该线程所处理的Socket所对应的输入流
10. BufferedReaderbr=null;
12. /**
13. *连接请求
14. */
15. publicstaticfinalStringOPERATION_CONNECT="CN";
17. /**
18. *方向
19. */
20. publicstaticfinalStringOPERATION_DIRECTION_TOP="DT";
21. publicstaticfinalStringOPERATION_DIRECTION_BOTTOM="DB";
22. publicstaticfinalStringOPERATION_DIRECTION_LEFT="DL";
23. publicstaticfinalStringOPERATION_DIRECTION_RIGHT="DR";
25. /**
26. *音量
27. */
28. publicstaticfinalStringOPERATION_VOLUME="VO";
30. /**
31. *亮度
32. */
33. publicstaticfinalStringOPERATION_BRIGHTNESS="BR";
35. /**
36. *单击&确认
37. */
38. publicstaticfinalStringOPERATION_CLICK="CL";
40. /**
41. *菜单
42. */
43. publicstaticfinalStringOPERATION_MENU="ME";
45. /**
46. *返回
47. */
48. publicstaticfinalStringOPERATION_BACK="BA";
50. /**
51. *电源
52. */
53. publicstaticfinalStringOPERATION_POWER="PO";
55. /**
56. *Home
57. */
58. publicstaticfinalStringOPERATION_HOME="HO";
61. publicServerThread(Sockets)
62. throwsIOException
63. {
64. this.s=s;
65. //初始化该Socket对应的输入流
66. br=newBufferedReader(newInputStreamReader(s.getInputStream(),"utf-8"));//②
68. }
70. /**
71. *向所有接入客户端发信息sendMessageToClient
72. */
73. publicsynchronizedstaticvoidsendMessageToClient(Stringmsg){
74. Log.v("","sendMessageToClient-->:"+msg);
76. //遍历socketList中的每个Socket，
77. //将读到的内容向每个Socket发送一次
78. for(Sockets:SocketService.socketList)
79. {
80. try{
81. OutputStreamos=s.getOutputStream();
82. os.write((msg+"\n").getBytes("utf-8"));
83. }catch(IOExceptione){
84. e.printStackTrace();
85. Log.e("","-->sendMessageToClienterror<--删除该Socket:"+s);
86. //删除该Socket。
87. SocketService.socketList.remove(s);//①
88. }
89. }
90. }
92. /**
93. *此线程不断接收客户端发过来的请求信息
94. */
95. publicvoidrun()
96. {
97. try
98. {
99. Stringcontent=null;
100. //采用循环不断从Socket中读取客户端发送过来的数据
101. while((content=readFromClient())!=null)
102. {
104. if(content.length()<2)continue;//避免发送空指令或错误指令导致异常
106. StringrequestStr=content.substring(0,2);
107. Log.v("","SocketServer--->content:"+content+",requestStr:"+requestStr);
109. if(requestStr.endsWith(OPERATION_VOLUME)){
110. MainActivity.systemManager.CtrlVolume(content);
111. }elseif(requestStr.endsWith(OPERATION_BRIGHTNESS)){
112. MainActivity.systemManager.CtrlBrightness(content);
113. }
115. //TODO未完成，下篇完成
117. }
118. }
119. catch(Exceptione)
120. {
121. e.printStackTrace();
122. }
123. }
126. /**
127. *定义读取客户端数据的方法
128. *@return接收到的请求信息
129. */
130. privateStringreadFromClient()
131. {
132. try
133. {
134. returnbr.readLine();
135. }
136. //如果捕捉到异常，表明该Socket对应的客户端已经关闭
137. catch(IOExceptione)
138. {
139. //删除该Socket。
140. SocketService.socketList.remove(s);
141. MainActivity.mHandler.sendEmptyMessage(MainActivity.CONN_ERROR);
142. }
143. returnnull;
144. }
145. }

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

1. /**
2. *控制系统的逻辑类
3. *@authorzzp
4. *
5. */
6. publicclassSystemManager{
7. privateAudioManageraudioManager;
8. privateActivitymActivity;
9. privatestaticintbrightnessNum=2;
11. publicSystemManager(){
12. mActivity=MainActivity.mActivity;
13. audioManager=(AudioManager)mActivity.getSystemService(Context.AUDIO_SERVICE);
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. }
21. /**
22. *媒体音量增减
23. */
24. publicvoidCtrlVolume(StringctrlCode){
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. }
41. /**
42. *系统亮度增减
43. */
44. publicvoidCtrlBrightness(StringctrlCode){
45. if(brightnessNum<0||brightnessNum>5)brightnessNum=2;
47. if(ctrlCode.contains("-")){
48. if(brightnessNum>0)brightnessNum--;
49. }else{
50. if(brightnessNum<5)brightnessNum++;
51. }
53. Messagemsg=newMessage();
54. msg.what=SocketService.SET_BRIGHTNESS;
55. msg.obj=(brightnessNum)*1.0f/5;
56. SocketService.mHandler.sendMessage(msg);
57. }
59. /**
60. *获取屏幕的亮度
61. *
62. *@paramactivity
63. *@return
64. */
65. publicstaticintgetScreenBrightness(Activityactivity){
66. intnowBrightnessValue=0;
67. ContentResolverresolver=activity.getContentResolver();
68. try{
69. nowBrightnessValue=android.provider.Settings.System.getInt(
70. resolver,Settings.System.SCREEN_BRIGHTNESS);
71. }catch(Exceptione){
72. e.printStackTrace();
73. }
74. returnnowBrightnessValue;
75. }
77. /**
78. *设置系统亮度
79. *@parambrightness:0~1
80. */
81. publicstaticvoidsetBrightness(Activityactivity,floatbrightness)
82. {
83. WindowManager.LayoutParamslp=activity.getWindow().getAttributes();
84. lp.screenBrightness=brightness;//这里设置范围0~1.0
85. activity.getWindow().setAttributes(lp);
87. Settings.System.putInt(activity.getContentResolver(),
88. android.provider.Settings.System.SCREEN_BRIGHTNESS,
89. (int)(brightness*255));
90. }
92. /**
93. *保存亮度设置状态
94. *
95. *@paramresolver
96. *@parambrightness:0~1
97. */
98. publicstaticvoidsaveBrightness(ContentResolverresolver,floatbrightness){
99. Uriuri=android.provider.Settings.System
100. .getUriFor("screen_brightness");
101. android.provider.Settings.System.putInt(resolver,"screen_brightness",
102. (int)(brightness*255));
104. resolver.notifyChange(uri,null);
105. }
108. }

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

1. /**
2. *与wifi相关
3. */
4. publicclassWifiAdmin
5. {
6. //定义WifiManager对象
7. privateWifiManagermWifiManager;
8. //定义WifiInfo对象
9. privateWifiInfomWifiInfo;
10. //扫描出的网络连接列表
11. privateList<ScanResult>mWifiList;
12. //网络连接列表
13. privateList<WifiConfiguration>mWifiConfiguration;
14. //定义一个WifiLock
15. WifiLockmWifiLock;
16. //构造器
17. publicWifiAdmin(Contextcontext)
18. {
19. //取得WifiManager对象
20. mWifiManager=(WifiManager)context.getSystemService(Context.WIFI_SERVICE);
21. //取得WifiInfo对象
22. mWifiInfo=mWifiManager.getConnectionInfo();
23. }
24. //打开WIFI
25. publicvoidOpenWifi()
26. {
27. if(!mWifiManager.isWifiEnabled())
28. {
29. mWifiManager.setWifiEnabled(true);
31. }
32. }
33. //关闭WIFI
34. publicvoidCloseWifi()
35. {
36. if(!mWifiManager.isWifiEnabled())
37. {
38. mWifiManager.setWifiEnabled(false);
39. }
40. }
41. //锁定WifiLock
42. publicvoidAcquireWifiLock()
43. {
44. mWifiLock.acquire();
45. }
46. //解锁WifiLock
47. publicvoidReleaseWifiLock()
48. {
49. //判断时候锁定
50. if(mWifiLock.isHeld())
51. {
52. mWifiLock.acquire();
53. }
54. }
55. //创建一个WifiLock
56. publicvoidCreatWifiLock()
57. {
58. mWifiLock=mWifiManager.createWifiLock("Test");
59. }
60. //得到配置好的网络
61. publicList<WifiConfiguration>GetConfiguration()
62. {
63. returnmWifiConfiguration;
64. }
65. //指定配置好的网络进行连接
66. publicvoidConnectConfiguration(intindex)
67. {
68. //索引大于配置好的网络索引返回
69. if(index>mWifiConfiguration.size())
70. {
71. return;
72. }
73. //连接配置好的指定ID的网络
74. mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,true);
75. }
76. publicvoidStartScan()
77. {
78. mWifiManager.startScan();
79. //得到扫描结果
80. mWifiList=mWifiManager.getScanResults();
81. //得到配置好的网络连接
82. mWifiConfiguration=mWifiManager.getConfiguredNetworks();
83. }
84. //得到网络列表
85. publicList<ScanResult>GetWifiList()
86. {
87. returnmWifiList;
88. }
89. //查看扫描结果
90. publicStringBuilderLookUpScan()
91. {
92. StringBuilderstringBuilder=newStringBuilder();
93. for(inti=0;i<mWifiList.size();i++)
94. {
95. stringBuilder.append("Index_"+newInteger(i+1).toString()+":");
96. //将ScanResult信息转换成一个字符串包
97. //其中把包括：BSSID、SSID、capabilities、frequency、level
98. stringBuilder.append((mWifiList.get(i)).toString());
99. stringBuilder.append("/n");
100. }
101. returnstringBuilder;
102. }
103. //得到MAC地址
104. publicStringGetMacAddress()
105. {
106. return(mWifiInfo==null)?"NULL":mWifiInfo.getMacAddress();
107. }
108. //得到接入点的BSSID
109. publicStringGetBSSID()
110. {
111. return(mWifiInfo==null)?"NULL":mWifiInfo.getBSSID();
112. }
113. //得到IP地址
114. publicintGetIPAddress()
115. {
116. return(mWifiInfo==null)?0:mWifiInfo.getIpAddress();
117. }
118. //得到连接的ID
119. publicintGetNetworkId()
120. {
121. return(mWifiInfo==null)?0:mWifiInfo.getNetworkId();
122. }
123. //得到WifiInfo的所有信息包
124. publicStringGetWifiInfo()
125. {
126. return(mWifiInfo==null)?"NULL":mWifiInfo.toString();
128. }
129. //添加一个网络并连接
130. publicvoidAddNetwork(WifiConfigurationwcg)
131. {
132. intwcgID=mWifiManager.addNetwork(wcg);
133. mWifiManager.enableNetwork(wcgID,true);
134. }
135. //断开指定ID的网络
136. publicvoidDisconnectWifi(intnetId)
137. {
138. mWifiManager.disableNetwork(netId);
139. mWifiManager.disconnect();
140. }
142. //将127.0.0.1形式的IP地址转换成十进制整数，这里没有进行任何错误处理
143. publicstaticlongipToLong(StringstrIp){
144. long[]ip=newlong[4];
145. //先找到IP地址字符串中.的位置
146. intposition1=strIp.indexOf(".");
147. intposition2=strIp.indexOf(".",position1+1);
148. intposition3=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. }
157. //将十进制整数形式转换成127.0.0.1形式的ip地址
158. publicstaticStringlongToIP(longlongIp){
159. StringBuffersb=newStringBuffer("");
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. returnsb.toString();
172. }
173. }

g.Manifest.xml(配置文件)需要添加权限 [html] view plain copy

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

四、后记&下篇内容 本例中设置系统亮度未能很好的实现，每次设置亮度都会进行判断当前系统显示的Activty，而设置亮度目前需要到服务端界面设置才成功，所以退出服务端界面后，设置系统亮度会进行判断，如果当前不是显示服务端MainActivity，则在服务中重新打开。 下篇主要内容是模拟系统按键消息，单击事件，滚动事件等。 参考引用： 1.《李刚疯狂Android讲义》十三章 2.Android APIs： http://developer.android.com/reference/java/net/ServerSocket.html

更多相关文章

1. Android后端服务器的搭建方法
2. 手机淘宝Android客户端架构
3. 南青信息查询 for Android客户端
4. Android客户端与服务器端交互，如何保持session回话
5. Android实现录屏直播（三）MediaProjection + VirtualDisplay + libr
6. 微服务-Android客户端: 实现注册和登录

随机推荐

1. Androd之在图片右上角显示红色圆圈里面数
2. [Android]Android(安卓)Studio导入第三方
3. Android应用开发提高系列（5）——Android动
4. Android学习之菜单
5. android 发送邮件
6. Android零碎知识点（6）——下拉列表框Spinne
7. android中用Spannable在TextView中设置超
8. android中使用定时任务
9. Win7上Git安装及简单配置过程
10. Android(安卓)复习 Content Provider