新普金娱乐网址


android String能源 包涵 数学符号等很是字符 及 参数占位符

Plato为啥不予民主

报考博士泄题,泄的是人生的一味

  • 四月 05, 2019
  • 数学
  • 没有评论

正文转自:http://www.cnblogs.com/qingblog/archive/2012/06/15/2550735.html

一:泄题,泄的是人生的唯有

报考学士数学泄题了,看到那条音讯的时候,心里豁然刺痛了1晃。

想起了高级中学年老年师说过的一句话:“高等高校统招考试大概是你们此生经历的最终一场也是唯一一场公平的试验了。 ”

早先是不信的,可未来切实可行就摆在日前,狠狠击打着自身的伤痕,猖狂着将我的1味踩碎。露天是艳阳天,然,笔者的心尖却不曾一丝光亮透进来。

怀着希望和向往远赴斯科学普及里,以为自个儿不过接近梦想,走到前几天却突然有种深深的优伤和无力感。

经验过的丰姿知道,当你起早贪黑的着力,倾尽全力满怀期待的完成一件对您的话具有重疏忽义的以后,却突然被报告,早已经有人拿着通关凭证,轻而易举就把你从云端踢到山沟,而你只好傻乎乎地立在原地欲哭无泪,那到底是1种怎么着的彻底。

阅览那一届报考大学生的读书人哭的那么难过,小编豁然忍不住,全数的哀伤全部涌上心头,一位蹲在洗手间痛哭、捶墙。不想那样矫情,但是,不自觉地心疼他们啊,心痛他们的着力,也心痛他们通晓真相后的坚强。

曾几何时,以为踮起脚尖就足以触碰太阳,可未来才清楚
,太阳也挑人的,不成文规定不是电视机剧的专利,还有一个地点,它称为现实,比起虚拟的电视剧尤其的淡淡,越发的暴虐。

 

二:梦想,梦的是天真善良

本身是个专科生,却不甘人后,身怀美好的名特别降价,也倾尽全力的奋力着,为了心中明晰且坚定的梦,脚踏实地地狂奔着,一刻也不敢松懈。因为小编晓得,源点越低
,就越要提交比外人越多的用力。
为了考到1线城市,为了考上自身喜爱的正式,我打算用4年岁月来表明自身,所以,笔者恶补法语,差不离每一日泡在体育场合,博学多才,相当于想和本科生减少一点偏离。

再则,小编想要考的是武大。

可未来,遑论报考硕士,作为一个底部的专科生,小编第二要面对的是专科毕业生升入本科那一座大山。

二〇一玖年,作者将面临专科毕业生升入本科。专科毕业生升入本科里的中间猫腻,作者刻意不去听,不去想,可就算专科毕业生升入本科的名额都不属于自家,那作者还拿什么去竞争呢?指引员的势利心机让自身的心凉了一大截,看到他们蜂拥而至讨好教导员,作者倔强的选择了沉默。被吞占名额的奖学金,还有这么些不可言说的秘闻,笔者选取了深埋心底。

极其羡慕外人家的指引员,可自笔者不是外人家的子女。在其位谋其政,身处自个儿的这些职务,只可以协调找解决办法,没人能够帮你。

自家只是3个常常的人,2个未曾任何关系可用的人,我慕名着外面包车型客车社会风气,小编想去巴黎东京,想赚很多浩大的钱,想让自个儿的父母不再受苦受累,想让自家的孩子能够在大城市居住。我奋力善良,对每种人笑,然则实际对自身笑啊,愈演愈烈的残忍的切实啊,你能对本人笑吗?

门户不小程度上控制了上层建筑,作者熟稔此理,可本人的性情不会容许本人伏地认输。关系也好,不公道也好,漆黑也罢,光明也罢,都固然了,作者高度地爱惜着自小编的期待,笑着报告它,你别怕,作者会来的,笔者会取得彻底,小编会铁面无私的赶来你的身旁。

后天古时候文学的良师说,硕士难以写出好的稿子来,因为缺乏经验和深度,内容往往空乏单调缺少暗意。好,既然那样,那自个儿就去伤痛里走壹遭吧,加深一下自笔者的沉思,给自个儿的文章润润色,何乐不为呢。

自个儿只是想变得更加好,哪怕折断本身的翎翅,哪怕淋湿作者的眸子。

也只是为了变得更加好。

先是部分 Android网络基础
   Android平台浏览器采取了WeBKit引擎,那款名字为Chorme
Lite的Web浏览器拥有无敌增添天性,
每一个开发者都觉得编写本人的插件,使得浏览器的机能更是完善。
   近日Android平台有三种网络接口。
  第一种 java.net.*(标准java接口)
  
此接口提供与联网有关的类,包罗流和数据包套接字、Internet协议、常见HTTP处理。
如:创建URL以及URLConnection/HttpURLConnection对象、
安装连接参数、连接服务器、向服务器写多少、从服务器读取数据等通讯。
   下例为常见java.net包的Http例子:
   try{
    URL url = new URL(“http://www.google.com%22)//概念地址
    HttpUEscortLConnection http = (HttpU兰德KoleosLConnection)
url.openConnection();//打开连接
    int nLANDC = http.getResponseCode();//获得一连情状
    if(nRC == HttpURLConnection.HTTP_OK){
     InputStream is = http.getInputStream();//取得数据
     …..//处理数据
    }
   }catch(Exception e){
    //因是接二连三网络,不免会现出局地分外,所以必须处理那些万分
   }
  第二种 Apache接口
   Android提供的Apache HttpClient,它是多少个开源项目,功用尤为完美,
   为客户端的Http编制程序提供便捷、最新、作用充裕的工具包。
   Android近年来使用的是HttpClient四.0(org.apache.http.*),
可将Apache看为当前盛行的开源Web服务器,
驷不如舌包蕴创设HttpClient以及Get/Post、HttpRequest等对象,设置连接参数,执行HTTP操作,
   处理服务器重返结果等成效。
   下例为使用android.net.http.*包的例证:
   try{
    HttpClient hc = new
DefaultHttpClient();//创制HttpClient,那里运用DefaultHttpClient表示暗中同意属性
    HttpGet hg = new
HttpGet(“http://www.google.com%22);//HttpGet实例
    HttpResponse rp = hc.execute(hg);//连接
    if(rp.getStatusLine().getStatusCode() == HttpStatus.SC_OK){
     InputStream is = rp.getEntity().getContent();
     …..//处理数据
    }
   }catch(IOEeception e){
   }
  第1中 Android互联网接口
  
android.net.*包实在是透过Apache中HttpClient的卷入来贯彻的二个HTTP编制程序接口,
再正是还提供了Http请求队列管理以及Http连接池管理,以加强并发请求境况下(如装载网页时)的作用
   还包含互连网状态监视等接口,互联网访问的Socket,常用的Uri类以及关于WiFi相关的类等等。
   下例为最简便易行的Socket连接
   try{
    InetAddress ia = InetAddress.getByName(“192.168.1.110”);//IP地址
    Socket sk = new Socket(inetAddress,61203,true);//端口
    InputStream is =sk.getInputStream();//获得数码
    OutputStream os = sk.getOutputStream();
    …..//数据处理
    os.close();
    is.close();
    sk.close();
   }catch(UnknownHostException e){
   }catch(IOException e){
   }
第贰部分 Http通讯
   Android提供了HttpUENVISIONLConnection和HttpClient接口来支付Http程序。
   Http(Hyper Text Transfer
Protocol,超文本传输协议)用于传输WWW格局的数目。
  
HTTP通讯中型地铁户端发送的历次请求都急需服务器回送响应,在央求甘休后,会积极性释放连接。
从成立连接到关闭连接的长河为”3遍三番五次”。
要保障客户端程序在线状态,供给持续地向服务器发送连接请求。
普普通通的做法是不怕不须要取得其余数据,客户端也维持没隔一段固定的日子向服务器发送1回“保持一而再”的伸手,
服务器在接到该请求后对客户端进行恢复生机,表明知道客户端在线。
若长期无从接受客户端的央求,则以为客户端下线,若客户端长期无从吸收服务器的过来,则觉得互连网已经断开。
不少状态下,供给劳务器端主动向客户端发送数据以保全客户端与服务器数据的实时与一起。
Http通讯中,服务器要求等到客户端发送一回呼吁后才能将数据传回给客户端,
故此,客户端定时向劳动器端发送连接请求,不仅能够维持在线,
再就是也是在”询问”服务器是或不是有新数据,假诺有就将数据传给客户端。
  
   Http采取请求/响应的方式。
客户端向服务器发送三个请求,
请求头包含了请求方法,U兰德揽胜I,协议版本,以及富含呼吁修饰符,客户新闻和内容,类似于MIME音讯结构。
服务器以四个情形行作为响应,响应的内容涵盖音讯协议的本子,成功或不当编码,
还包涵服务器消息,实体元新闻以及或许的实业内容。
它是多个属于应用层的面向对象的情商,适用于分布式超媒体新闻类别。

三:碎碎念

黑马想到倘若自个儿没能考上怎么办,唉,小事,扣壶长吟的人那么多,何况作者还失实,毫无才华。未有苏子瞻挥毫千里的风骚,亦无李清照对影自怜的苍凉,作者呀,有的只是一腔绘影绘声的心腹,还有和时间稳步耗弄的淡漠。

爬也要爬到终点,那是自身的信念,从自家主宰不顾一切地逆风飞翔初阶,小编就不会回头。

泄题是啊,好,那本身就考的比你拿走题的人幸亏,优良到您不大概把小编刷掉。

谢谢看完作者碎碎念的你们,作者很好,无需驰念,愿大家大家都笑脸常在,愿这几个世界多一点公平。

最终,愿那届的考生们振作起来,都具备“野火烧不尽,春风吹又生”的委曲求全。

  
许多HTTP通讯是由二个用户代理伊始化的,并且囊括一个申请在源服务器上能源的请求。
最简便的情事大概是在用户代理和服务器之间通过一个独门的连日来形成。
  
在Internet上,Http通讯常常发生在TCP/IP连接上,缺省端口是TCP80.别样端口也是可用的。
  第一种 HttpURLConnection接口
   Http通信中央银行使最多的是Get和Post.
  
Get请求可用获得静态页面,也得以把参数放在URL字串的前面,传递给服务器。
   Post参数不是放在UHavalL字串里面,而是放在http请求数据中。
   U汉兰达LConnection与HttpU大切诺基LConnection都以抽象类,不能够间接实例化对象。
其指标首要通过U帕杰罗L的openConnection方法赢得,
但openConnection方法只是创办URAV肆LConnection也许HttpUTucsonLConnection
的实例,并不是展开真正的连接操作。
所以在接连从前大家可用对有的属性举办安装
   对HttpConnection实例的品质设置:
    connection.setDoOutput(true);//设置输出流
    connection.setDoInput(true);//设置输出流
    connection.setRequestMethod(“POST”);//设置方法为POST
    connection.setUseCaches(false);//Post请求不能利用缓存
    urlConn.disconnect();//连接形成之后关闭HttpUPRADOLConnection连接
   
   首先在服务器上建立一个不要求传递参数的网页http一.jsp文书。代码如下:
   <HTML>
    <HEAD>
     <TITLE>
      Http Test
     </TITLE>
    </HEAD>
    <BODY>
     <% out.println(“<h1>HTTP TEST<br>http
test</h1>”); %>
    </BODY>
   </HTML>
   再次创下造1个适用Get和Post来传递参数的网页httpget.jsp 代码如下:
   <%@ page language=”java” import = “java.util.*” pageEncoding =
“gb2312” %>
   <HTML>
    <HEAD>
     <TITLE>
      Http Test
     </TITLE>
    </HEAD>
    <BODY>
     <%
      String type = request.getParameter(“par”);
      String result = new
String(type.getBytes(“iso-8859-1″)),”gb2312”);
      out.println(“<h1>parameters:”+result+”</h1>”);
     %>
    </BODY>
   </HTML>
   以下例中通过Android程序分别以分歧的章程访问那多少个页面。
   main.xm 文件
   <?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”>
     <TextView
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”通过上面包车型大巴按钮举行区别措施的接连”/>
     <Button
      android:id=”@+id/Button_HTTP”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”间接获取数据”/>
     <Button
      android:id=”@+id/Button_Get”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”以GET情势传递数据”/>
     <Button
      android:id=”@+id/Button_Post”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”以POST情势传递数据”/>
    </LinearLayout>

   http.xml文件
   <?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”
     >
     <TextView 
      android:id=”@+id/TextView_HTTP”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
     />
     <Button
      android:id=”@+id/Button_Back”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”返回”/>
    </LinearLayout>
   
   public class Activity01 extends
Activity{//进入界面达成三个控件的Activity
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
 
     Button button_http = (Button) findViewById(R.id.Button_HTTP);
     /* 监听button的风浪信息 */
     button_http.setOnClickListener(new Button.OnClickListener() {
      public void onClick(View v){
       /* 新建多个Intent对象 */
       Intent intent = new Intent();
       /* 钦点intent要运营的类 */
       intent.setClass(Activity01.this, Activity02.class);
       /* 运维三个新的Activity */
       startActivity(intent);
       /* 关闭当前的Activity */
       Activity01.this.finish();
      }
     });
     Button button_Get = (Button) findViewById(R.id.Button_Get);
     /* 监听button的轩然大波新闻 */
     button_Get.setOnClickListener(new Button.OnClickListener() {
      public void onClick(View v){
       /* 新建二个Intent对象 */
       Intent intent = new Intent();
       /* 钦定intent要开动的类 */
       intent.setClass(Activity01.this, Activity03.class);
       /* 运维2个新的Activity */
       startActivity(intent);
       /* 关闭当前的Activity */
       Activity01.this.finish();
      }
     });
     Button button_Post = (Button) findViewById(R.id.Button_Post);
     /* 监听button的轩然大波消息 */
     button_Post.setOnClickListener(new Button.OnClickListener() {
      public void onClick(View v){
       /* 新建一个Intent对象 */
       Intent intent = new Intent();
       /* 钦赐intent要开动的类 */
       intent.setClass(Activity01.this, Activity04.class);
       /* 运维3个新的Activity */
       startActivity(intent);
       /* 关闭当前的Activity */
       Activity01.this.finish();
      }
     });
    }
   }
  
   public class Activity02 extends Activity{//直接获取数据
    private final String DEBUG_TAG = “Activity02”;
     public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.http);
    
     TextView mTextView =
(TextView)this.findViewById(R.id.TextView_HTTP); 
     String httpUrl =
http://192.168.1.110:8080/http1.jsp%22;//http地址
     String resultData = “”;//获得的数目
     URL url = null;
     try{ 
      url = new U途观L(httpUrl); //构造一个UHighlanderL对象
     }catch (MalformedURLException e){
      Log.e(DEBUG_TAG, “MalformedURLException”);
     }
     if (url != null){
      try{   
       HttpU中华VLConnection urlConn = (HttpU揽胜极光LConnection)
url.openConnection();//使用HttpUPAJEROLConnection打开连接   
       InputStreamReader in = new
InputStreamReader(urlConn.getInputStream());//获得读取的始末(流)   
       BufferedReader buffer = new Buffered里德r(in);//
为出口创立BufferedReader
       String inputLine = null;  
       while (((inputLine = buffer.readLine()) !=
null)){//使用循环来读取获得的数码   
        resultData += inputLine +
“\n”;//大家在每一行后边加上贰个”\n”来换行
       }      
       in.close();//关闭InputStreamReader  
       urlConn.disconnect();//关闭http连接   
       if ( resultData != null ){
        mTextView.setText(resultData);//设置显示取得的始末
       }else {
        mTextView.setText(“读取的始末为NULL”);
       }
      }catch (IOException e){
       Log.e(DEBUG_TAG, “IOException”);
      }
     }else{
      Log.e(DEBUG_TAG, “Url NULL”);
     } 

     Button button_Back = (Button)
findViewById(R.id.Button_Back);//设置按键事件监听
      button_Back.setOnClickListener(new
Button.OnClickListener(){//监听button的风云新闻
       public void onClick(View v){   
        Intent intent = new Intent();
        intent.setClass(Activity02.this, Activity01.class);   
        startActivity(intent);
        Activity02.this.finish();
       }
      });
    }
   }

   public class Activity0三 extends Activity{//以Get格局上传参数
    private final String DEBUG_TAG = “Activity03”;
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.http);
 
     TextView mTextView =
(TextView)this.findViewById(R.id.TextView_HTTP); 
     String httpUrl =
http://192.168.1.110:8080/httpget.jsp?par=abcdefg%22;//http地点”?par=abcdefg”是大家上传的参数
     String resultData = “”;//得到的数码
     URL url = null;
     try{  
      url = new U昂科拉L(httpUrl); //构造三个U奥迪Q5L对象
     }catch (MalformedURLException e){
      Log.e(DEBUG_TAG, “MalformedURLException”);
     }
     if (url != null){
      try{   
       HttpUGL450LConnection urlConn = (HttpU陆风X8LConnection)
url.openConnection();// 使用HttpUPRADOLConnection打开连接   
       InputStreamReader in = new
InputStream里德r(urlConn.getInputStream());//得到读取的内容(流)  
       BufferedReader buffer = new BufferedReader(in); //
为出口创立BufferedReader
       String inputLine = null;   
       while (((inputLine = buffer.readLine()) !=
null)){//使用循环来读取获得的多少   
        resultData += inputLine +
“\n”;//大家在每1行后边加上贰个”\n”来换行
       }       
       in.close();//关闭InputStreamReader   
       urlConn.disconnect();//关闭http连接  
       if ( resultData != null ){
        mTextView.setText(resultData);//设置突显取得的内容
       }else {
        mTextView.setText(“读取的内容为NULL”);
       }
      }catch (IOException e){
       Log.e(DEBUG_TAG, “IOException”);
      }
     }else{
      Log.e(DEBUG_TAG, “Url NULL”);
     }

     Button button_Back = (Button) findViewById(R.id.Button_Back);
      button_Back.setOnClickListener(new Button.OnClickListener() {
       public void onClick(View v){
        Intent intent = new Intent();
        intent.setClass(Activity03.this, Activity01.class);
        startActivity(intent);
        Activity03.this.finish();
       }
      });
    }
   }

   public class Activity0四  extends Activity{//以Post格局上传参数
    private final String DEBUG_TAG = “Activity04”;
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.http);
 
     TextView mTextView =
(TextView)this.findViewById(R.id.TextView_HTTP);
     String httpUrl =
http://192.168.1.110:8080/httpget.jsp%22;//http地址”?par=abcdefg”是大家上传的参数 
     String resultData = “”;//获得的数据
     URL url = null;
     try{ 
      url = new U宝马X三L(httpUrl); //构造八个ULacrosseL对象
     }catch (MalformedURLException e){
      Log.e(DEBUG_TAG, “MalformedURLException”);
     }
     if (url != null){
      try{  
       HttpUOdysseyLConnection urlConn = (HttpUWranglerLConnection)
url.openConnection();// 使用HttpU卡宴LConnection打开连接  
      
urlConn.setDoOutput(true);//因为那一个是post请求,设立须要安装为true
       urlConn.setDoInput(true);        
       urlConn.setRequestMethod(“POST”);// 设置以POST方式        
       urlConn.setUseCaches(false);// Post 请求不可能动用缓存
       urlConn.setInstanceFollowRedirects(true);        
      
urlConn.setRequestProperty(“Content-Type”,”application/x-www-form-urlencoded”);
//
配置本次连接的Content-type,配置为application/x-www-form-urlencoded的
       //
连接,从postUrl.openConnection()至此的布署必供给在connect从前到位,
       // 要小心的是connection.getOutputStream会隐含的展开connect。
       urlConn.connect();   
       DataOutputStream out = new
DataOutputStream(urlConn.getOutputStream());//DataOutputStream流         
       String content = “par=” + U福特ExplorerLEncoder.encode(“ABCDEFG”,
“gb2312”);//要上传的参数        
       out.writeBytes(content); //将要上传的始末写入流中        
       out.flush();//刷新、关闭
       out.close();          
       BufferedReader reader = new BufferedReader(new
InputStreamReader(urlConn.getInputStream()));//获取数据
       String inputLine = null;   
       while(((inputLine = reader.readLine()) !=
null)){//使用循环来读取得到的数码   
        resultData += inputLine +
“\n”;//大家在每一行前边加上2个”\n”来换行
       }   
       reader.close();
       urlConn.disconnect();//关闭http连接   
       if ( resultData != null ){
        mTextView.setText(resultData);//设置显示取得的内容
       }else{
        mTextView.setText(“读取的始末为NULL”);
       }
      }catch (IOException e){
       Log.e(DEBUG_TAG, “IOException”);
      }
     }else{
      Log.e(DEBUG_TAG, “Url NULL”);
     } 

     Button button_Back = (Button) findViewById(R.id.Button_Back);
      button_Back.setOnClickListener(new Button.OnClickListener(){
       public void onClick(View v){
        Intent intent = new Intent();
        intent.setClass(Activity04.this, Activity01.class);
        startActivity(intent);
        Activity04.this.finish();
       }
      });
    }
   }

  
上面实现的是网络通讯自是文件格局的,借使要展现互联网上的一张图纸,连接格局和近来相同,
只要求将一而再之后收获数码流转换来Bitmap就足以了。
   下例为体现互联网图片的点子
   GetNetBitmap方法
   //取得互联网上的图形
   //url:图片地址
   public Bitmap GetNetBitmap(String url){
    URL imageUrl = null;
    Bitmap bitmap = null;
    try{
     imageUrl = new URL(url);
    }catch(MalformedURLException){
     Log.e(DEBUG_TAG,e.getMessage());
    }
    try{
     HttpURLConnection conn =
(HttpURLConnection)imageUrl.openConnection();
     conn.setDoInput(true);
     conn.connect();
     InputStream is =
conn.getInputStream();//将得到的数目转换到InputStream
     bitmap =
BitmapFactory.decodeStream(is);//将InputStream转换成Bitmap
     id.close();
    }catch(IOException e){
     Log.e(DEBUG_TAG,e.getMessage());
    }
   }

  第二种 HttpClient接口
  
与第二种相比较HttpClient对java.net中的类做了包装和浮泛,更契合大家在Android上支出互连网采纳。
   需掌握如下1些类:
   ClinetConnectionManager接口
    此接口是客户端连接管理器接口,有如下抽象方法:
    ClientConnectionManager  关闭全体无效、超时的接连
    closeIdleConnections  关闭空闲的延续
    releaseConnection   释放三个总是
    requestConnection   请求1个新的接连
    shutdown     关闭管理器并释放能源
   DefaultHttpClient
    是暗中同意的3个HTTP客户端,可用它创立3个Http连接 代码如下:
    HttpClinet httpclinet = new HttpClient();
   HttpResponse
   
是三个HTTP连接响应,当执行多个HTTP连接后,就会回到2个HttpResponse,能够因此HttpResponse获得部分响应的音讯。
    下例为呼吁三个HTTP连接并取得该请求是不是中标的代码:
    HttpResponse httpResponse = httpclient.execute(httpRequest);
    if(httpResponse.getStatusLine(),getStatusCode() ==
HttpStates.SC_OK){//判断是不是连接成功
    }
   下例中分头使用Get和Post格局请求二个网页
   main.xml文件
   <?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”
     >
     <TextView 
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”使用HttpClient来进行GET和POST连接”
     />
     <Button
      android:id=”@+id/Button_Get”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”以GET方式传递数据”/>
     <Button
      android:id=”@+id/Button_Post”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”以POST情势传递数据”/>
    </LinearLayout>

   http.xml文件
   <?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”
     >
     <TextView 
      android:id=”@+id/TextView_HTTP”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
     />
     <Button
      android:id=”@+id/Button_Back”
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”返回”/>
    </LinearLayout>
   
   public class Activity01 extends Activity{
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);

     Button button_Get = (Button) findViewById(R.id.Button_Get);
     /* 监听button的轩然大波音讯 */
     button_Get.setOnClickListener(new Button.OnClickListener() {
      public void onClick(View v){
       /* 新建二个Intent对象 */
       Intent intent = new Intent();
       /* 钦命intent要开动的类 */
       intent.setClass(Activity01.this, Activity02.class);
       /* 运转一个新的Activity */
       startActivity(intent);
       /* 关闭当前的Activity */
       Activity01.this.finish();
      }
     });
     Button button_Post = (Button) findViewById(R.id.Button_Post);
     /* 监听button的轩然大波消息 */
     button_Post.setOnClickListener(new Button.OnClickListener() {
      public void onClick(View v){
       /* 新建多个Intent对象 */
       Intent intent = new Intent();
       /* 钦点intent要运行的类 */
       intent.setClass(Activity01.this, Activity03.class);
       /* 运营三个新的Activity */
       startActivity(intent);
       /* 关闭当前的Activity */
       Activity01.this.finish();
      }
     });
    }
   }

   public class Activity0二 extends Activity{//Get格局呼吁例子
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.http);
     TextView mTextView = (TextView)
this.findViewById(R.id.TextView_HTTP);
 
     String httpUrl =
http://192.168.1.110:8080/httpget.jsp?par=HttpClient_android_Get%22;//
http地址 
     HttpGet httpRequest = new HttpGet(httpUrl);//HttpGet连接对象
     try{ 
      HttpClient httpclient = new
DefaultHttpClient();//取得HttpClient对象
      HttpResponse httpResponse =
httpclient.execute(httpRequest);//请求HttpClient,取得HttpResponse  
      if (httpResponse.getStatusLine().getStatusCode() ==
HttpStatus.SC_OK){//请求成功   
       String strResult =
EntityUtils.toString(httpResponse.getEntity());//取得重返的字符串
       mTextView.setText(strResult);
      }else{
       mTextView.setText(“请求错误!”);
      }
     }catch (ClientProtocolException e){
      mTextView.setText(e.getMessage().toString());
     }catch (IOException e){
      mTextView.setText(e.getMessage().toString());
     }catch (Exception e){
      mTextView.setText(e.getMessage().toString());
     }  
     Button button_Back = (Button)
findViewById(R.id.Button_Back);//设置按键事件监听
      button_Back.setOnClickListener(new Button.OnClickListener() {
       public void onClick(View v){
        Intent intent = new Intent();
        intent.setClass(Activity02.this, Activity01.class);
        startActivity(intent);
        Activity02.this.finish();
       }
      });
    }
   }
 
   public class Activity0三 extends Activity{//Post方式请求
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.http);
 
     TextView mTextView = (TextView)
this.findViewById(R.id.TextView_HTTP); 
     String httpUrl = “http://192.168.1.110:8080/httpget.jsp%22;//
http地址 
     HttpPost httpRequest = new HttpPost(httpUrl);//HttpPost连接对象
    
     List<NameValuePair> params = new
ArrayList<NameValuePair>();//使用NameValuePair来保存要传送的Post参数 
     params.add(new BasicNameValuePair(“par”,
“HttpClient_android_Post”));//添加要传递的参数
     try{
      HttpEntity httpentity = new UrlEncodedFormEntity(params,
“gb2312”);//设置字符集,Post要求安装所采取的字符集
      httpRequest.setEntity(httpentity);//请求httpRequest
      HttpClient httpclient = new
DefaultHttpClient();//取得暗中认可的HttpClient
      HttpResponse httpResponse =
httpclient.execute(httpRequest);//取得HttpResponse 
      if (httpResponse.getStatusLine().getStatusCode() ==
HttpStatus.SC_OK){//HttpStatus.SC_OK代表连接成功  
       String strResult =
EntityUtils.toString(httpResponse.getEntity());//取得再次回到的字符串
       mTextView.setText(strResult);
      }else{
       mTextView.setText(“请求错误!”);
      }
     }catch (ClientProtocolException e){
      mTextView.setText(e.getMessage().toString());
     }catch (IOException e){
      mTextView.setText(e.getMessage().toString());
     }catch (Exception e){
      mTextView.setText(e.getMessage().toString());
     }   
     Button button_Back = (Button)
findViewById(R.id.Button_Back);//设置按键事件监听
      button_Back.setOnClickListener(new Button.OnClickListener() {
       public void onClick(View v){
        Intent intent = new Intent();
        intent.setClass(Activity03.this, Activity01.class);
        startActivity(intent);
        Activity03.this.finish();
       }
      });
    }
   }
其三有些 实时更新
   第三局部只是简短地叁遍性获得网页数据,
而在实际上付出中越来越多的是急需大家实时获取最新数据,比如道路流量,实时气象音信等等。
  
可通过几个线程来控制视图的翻新,要实时的从互联网获取数据,其实正是把得到互联网数据的代码写到线程中,不停的进展立异。
  
注意:Android中更新视图不可能直接在线程中举办,所以必要运用Handler来完毕革新。
  
下例中大家创造七个网页来突显系统当下的岁月,然后每隔伍秒系统活动刷新三回视图。
   首先,成立1个出示当前系统时间的jsp网页文件如下:
   date.jsp
   <% page language=”java” import=”java.util.*”
pageEncoding=”gb2312″%>
    <HTML>
     <HEAD>
      <TITLE>
       Date Test
      </TITLE>
     </HEAD>
     <BODY>
      <%java.text.SimpleDateFormat formatter = new
java.text.SimpleDateFormat(“yyyy-MM–dd HH:mm:ss”);>
     </BODY>
    </HTML>
  
   main.xml文件
   <?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”
     >
     <TextView 
      android:id=”@+id/TextView01″
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”@string/hello”
     />
     <Button
      android:id=”@+id/Button01″
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”刷新” />
    </LinearLayout>

   public class Activity01 extends Activity{
    private final String DEBUG_TAG = “Activity02”;
     private TextView mTextView;
     private Button mButton;
     public void onCreate(Bundle savedInstanceState){
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
     
      mTextView = (TextView)this.findViewById(R.id.TextView01);
      mButton = (Button)this.findViewById(R.id.Button01);
      mButton.setOnClickListener(new Button.OnClickListener(){
       public void onClick(View arg0){
        refresh();//刷新
       }
      }); 
      new Thread(mRunnable).start();//开启线程
     }
     private void refresh(){//刷新网页显示
      String httpUrl = “http://192.168.1.110:8080/date.jsp“;
      String resultData = “”;
      URL url = null;
      try{  
       url = new U中华VL(httpUrl);// 构造一个U景逸SUVL对象
      }catch (MalformedURLException e){
       Log.e(DEBUG_TAG, “MalformedURLException”);
      }
      if (url != null){
       try{   
        HttpU景逸SUVLConnection urlConn = (HttpURAV四LConnection)
url.openConnection();// 使用HttpU奥德赛LConnection打开连接   
        InputStreamReader in = new
InputStreamReader(urlConn.getInputStream());// 获得读取的情节(流)   
        BufferedReader buffer = new BufferedReader(in);//
为出口创制BufferedReader
        String inputLine = null;   
        while (((inputLine = buffer.readLine()) != null)){//
使用循环来读取获得的多少    
         resultData += inputLine + “\n”;//
大家在每1行前边加上一个”\n”来换行
        }   
        in.close();// 关闭InputStreamReader  
        urlConn.disconnect();// 关闭http连接  
        if (resultData != null){
         mTextView.setText(resultData);// 设置显示取得的情节
        }else{
         mTextView.setText(“读取的内容为NULL”);
        }
       }catch (IOException e){
        Log.e(DEBUG_TAG, “IOException”);
       }
      }else{
       Log.e(DEBUG_TAG, “Url NULL”);
      }
     }
     private Runnable mRunnable = new Runnable(){
      public void run(){
       while (true){
        try{
         Thread.sleep(5 * 1000);          
         mHandler.sendMessage(mHandler.obtainMessage());//发送新闻
        }catch (InterruptedException e){
         Log.e(DEBUG_TAG, e.toString());
        }
       }
      }
     };
     Handler mHandler = new Handler(){
      public void handleMessage(Message msg){
       super.handleMessage(msg);//接受信息      
       refresh();//刷新
      }
     };
   }

第陆有的 Socket通讯
  
假若要支付壹款几个人联网的嬉戏,Http已经不可能很好的满意必要了。那时就需求Socket通讯了。
   Socket平时称为”套接字”,用于描述IP地址和端口,是3个通讯链的句柄。
应用程序经常经过“套接字”向互连网发出请求也许应答网络请求。
它是通讯的木本,是永葆TCP/IP协议的网络
  
通讯的基本操作单元。它是网络通讯过程中端点的虚幻意味,包罗举办网络通讯必需的伍种音讯:
   
连接使用的说道、本地主机的IP地址、本地进度的商事端口、远地主机的IP地址、远地经过的协商端口。
  1、Socket传输方式
   Socket有三种重大操作形式:面向连接的 和 无连接的
    面向连接的Socket操作就如1部电话,必要求等对方接上之后才能打电话。
具有的数码到达的逐壹与它出发时的一1是1致的。
面向连接的操作使用TCP协议,即此情势下必须先再而三上目标地的Socket,
连日来上后Socket就可以运用2个流接口举行打开、读、写、关闭等操作。
全体所发消息都会在另壹端以同等的次第被收取。安全性高,但功效低。
   
无连接的就如七个邮件投递,未有管教,多个邮件到达时的各种恐怕与出发时的逐条不均等。
无连接的操作使用数据报业协会议,三个数据报是七个单身的单元,它涵盖了此次投递的享有新闻。
可将其想象成贰个信封,这几个格局下的Socket不需求连接一个目标Socket,它只是简短的投出数据报。
无连接的操作时神速和连忙的,可是多少安全性不高。
   
到底用哪类由应用程序的内需控制。如:文件服务器供给多少的正确性和有序性,因选面向连接的。
  二、Socket编制程序原理
   Socket构造
   
java.net包中提供五个类Socket和ServerSocket,分别用来表示双向连接的客户端和服务器端.
    两类中其构造方法如下:
    Socket(InetAddress address,int port);
    Socket(InetAddress address,int port,boolean stream);
    Socket(String host,int port);
    Socket(String host,int port,boolean stream);
    Socket(SocketImpl impl);
    Socket(String host,int port,InetAddress localAddr,int localPort);
    Socket(InetAddress address,int port,InetAddress localAddr,int
localPort);
    ServerSocket(int port);
    ServerSocket(int port,int backlog);
    ServerSocket(int port,int backlog,InetAddress bindAddr);
    当中参数意义:
     address      双向连接中另1方的IP地址
     host   双向连接中另一方的主机名
     port   双向连接中另壹方的端口号
     stream   指明Socket是流Socket依旧数据报Socket
     localPort  本地主机的端口号
     localAddr和bindAddr是地点机械的地址(ServerSocket的主机地址)
     impl  
是Socket的父类,即能够用来成立ServerSocket,又能够用来创设Socket
    例:
    //count表示服务端所协理的最加纳Ake拉接数
    Socket client = new Socket(“192.168.1.110”,54321);
    ServerSocket server = new ServerSocket(54321);
   
注意:在增选端口时每三个端口对应三个服务,唯有付出正确的端口,才能收获相应的劳务。0~102叁的端口号为系统所保存,例如http服务的端口号为80,telent服务的端口号
    为二壹,ftp服务的端口号为2三,所以选拔端口号时最佳选拔3个大于拾2叁的数
如上的543二一,防止发生抵触。在开创Socket时一旦发生错误,将发出IOException,所以在创制Socket
    和ServerSocket时务必捕获或抛出至极。
   Socket 客户端
   
要想选用Socket来与二个服务器通讯,就务须先在客户端成立一个Socket,并提出须要一而再的劳务器端的IP地址和端口,代码如下:
     try{
      Socket socket = new
Socket(“1玖二.168.一.1十”,33221);//”19二.16八.1.110″是IP地址,332二1是端口号
     }catch(IOException e){
     }
   ServerSocket 服务器端
    创造一个劳务器端的代码:
     ServerSocket server = null;
     try{
      server = new
ServerSocket(332二一);//服务器端在332二1端口号监听客户请求,在那边服务器端只可以接受多个伸手,接收后服务器端就淡出了。实际的运用香港中华总商会是让她不
              
停地循环往复接收,1旦有客户请求,服务器端总是会创建三个服务器线程来服务新来的客户,而协调则三番五次监听。
     }catch(IOException e){    
     }
     try{
      Socket socket = new
server.accpet();//accpet()为3个不通函数,即该措施被调用后将静观其变客户的乞求,直到有二个客户运转并呼吁连接到同样的端口,然后accept
              
再次回到二个相应于客户端的Socket.那时,客户方和劳务方都建立了用来通讯的Socket,接下去就由逐一Socket分别打开各自的输入
               输出流。
     }catch(IOExcetion e){
     }
   输入、输出流
    Socket
提供了getInputStream()和getOutPutStream()来获得相应的输入(输出)流以实行读(写)操作,那多个法子分别再次回到InputStream和OutputStream类对象。
   
为了方便读(写)数据,能够在回去输入、输出流对象上树立过滤流。如:DataInputStream、DataOutPutStream、或PrintStream类对象。对于文本方式流对象,能够使用
    InputStreamReader和OutputStreamWriter、PrintWirter处理 代码如下:
     PrintStream os = new PrintStream(new
BufferedOutputStream(Socket.getOutputStream()));
     DataInputStream is = new
DataInputStream(socket.getInputStream());
     PrintWriter out = new PrintWriter(socket.getOutStream(),true);
     BufferedReader in = new ButfferedReader(new
InputStreamReader(Socket.getInputStream()));
   关闭Socket和流
    在Socket使用完成后须求将其倒闭,以释放财富。
   
注意:在闭馆Socket以前,应将与Socket相关的具备的输入、输出流先关闭,以自由资源。要专注关闭的逐1。
     os.close();//输出流先关闭
     is.close();//输入流其次
     socket.close();//最终关闭Socket
   下例中
实现二个服务器和客户端通讯。客户端发送数据并接受服务器发回的多寡。
    public class Server implements Runnable{//服务器完结注意:该程序须求独自编写翻译,并在命令行情势下运营
     public void run(){
      try{  
       ServerSocket serverSocket = new
ServerSocket(543二壹);//创制ServerSocket 设置端口号为543二一
       while (true){  
        Socket client =
serverSocket.accept();//通过accept监听接受客户端请求
        System.out.println(“accept”);
        try{   
         BufferedReader in = new BufferedReader(new
InputStreamReader(client.getInputStream()));//通过BufferedReader对象收取客户端音信
         String str = in.readLine();
         System.out.println(“read:” + str);    
         PrintWriter out = new PrintWriter( new BufferedWriter( new
OutputStreamWriter(client.getOutputStream())),true); 
//通过PrintWriter向服务器发送音信,但
                                     需求通过Socket对象来取得其出口流
         out.println(“server message”);     
         out.close();//关闭流
         in.close();
        }catch (Exception e){
         System.out.println(e.getMessage());
         e.printStackTrace();
        }finally{    
         client.close();//关闭
         System.out.println(“close”);
        }
       }
      }catch (Exception e){
       System.out.println(e.getMessage());
      }
     }
     public static void main(String a[]){//main函数用来开启服务器
      Thread desktopServerThread = new Thread(new Server());
      desktopServerThread.start();//开启线程
     }
    }
    public class Activity01 extends Activity{//客户端
     private final String  DEBUG_TAG = “Activity01”;
     private TextView mTextView=null;
     private EditText mEditText=null;
     private Button  mButton=null;
     public void onCreate(Bundle savedInstanceState){
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
 
      mButton = (Button)findViewById(R.id.Button01);
      mTextView=(TextView)findViewById(R.id.TextView01);
      mEditText=(EditText)findViewById(R.id.EditText01);
   
      mButton.setOnClickListener(new OnClickListener(){//登陆
       public void onClick(View v){
        Socket socket = null;
        String message = mEditText.getText().toString() + “\r\n”;
        try {     
         socket = new Socket(“1九二.16八.一.1拾”,543二1);//创建Socket
连接服务器   
         PrintWriter out = new PrintWriter( new BufferedWriter( new
OutputStreamWriter(socket.getOutputStream())),true);
//向服务器发送音信    
         out.println(message);
         BufferedReader br = new BufferedReader(new
InputStreamReader(socket.getInputStream())); //接收来自服务器的新闻
         String msg = br.readLine(); //读取   
         if ( msg != null ){
          mTextView.setText(msg);//接受新闻后更新彰显到TextView中
         }else{
          mTextView.setText(“数据失实!”);
         }    
          out.close();//关闭流
          br.close();    
          socket.close(); //关闭Socket
        }catch (Exception e) {
         Log.e(DEBUG_TAG, e.toString());
        }
       }
      });
     }
    }
    通过上例总括了弹指间:
    使用Socket达成客户端的步调;
     一、通过IP地址和端口实例化Socket,请求连接服务器
     贰、获取Socket上的流以拓展读写
     叁、把流包装进BufferReader/PrintWriter的实例
     四、对Socket实行读写
     五、关闭打开的流
    创立服务器的步子:
     1、钦定端口实例化3个ServerSocket
     贰、调用ServerSocket的accept()以在等待连接时期造成堵塞
     三、获取位于该层Socket的流以开始展览读写操作
     肆、将数据封装成流
     5、对Socket进行读写
     陆、关闭打开的流

第陆有些 Socket应用—简易聊天室
  
第陆局地例证中实现了贰个客户端和三个服务器的独门通信,并且不得不一回通讯,
在事实上中,往往必要在服务器上运维贰个永恒的次第,它能够收到来自其余七个客户端的呼吁,并提供相应服务。
那就要求多线程来促成多客户机制。
服务器总是在钦点的端口上监听是还是不是有客户请求,壹旦监听到客户请求,
服务器就会运营一个特意的劳动线程来响应该客户的哀告,
而服务器本人在开发银行完线程后马上又进来监听状态,等待下二个客户。
  
   下例中应用Socket通讯完成了三个简便的聊天室程序。
   
下例我们供给运行五个客户端来还要连接服务器,三个客户端是Android程序,另2个是Java程序.
第壹运维服务器—运转Android客户端—运维另多少个PC客户端—-Android客户端
   
发送新闻—-pc客户端发送音信—Android客户端发送音信—-pc客户端发送音讯….
(当贰个客户端发送音讯(或再三再四服务器))后,服务器将向全部客户端发送二个音信,
那就须求服务器和客户端直接处于监听状态。
    main.xml文件
    <?xml version=”1.0″ encoding=”utf-8″?>
     <AbsoluteLayout
      xmlns:android=”http://schemas.android.com/apk/res/android
      android:orientation=”vertical”
      android:layout_width=”fill_parent”
      android:layout_height=”fill_parent”
      >
      <EditText
       android:id=”@+id/EditText01″
       android:text=”聊天记录:\n”
       android:layout_width=”fill_parent”
       android:layout_height=”200px”>
      </EditText>
      <EditText
       android:id=”@+id/EditText02″
       android:text=”输入要发送的始末”
       android:layout_width=”fill_parent”
       android:layout_height=”wrap_content”
       android:layout_y=”200px”>
      </EditText>
      <Button
       android:id=”@+id/Button_In”
       android:layout_width=”80px”
       android:layout_height=”wrap_content”
       android:text=”登陆”
       android:layout_x=”30px”
       android:layout_y=”260px”
       /> 
      <Button
       android:id=”@+id/Button_Send”
       android:layout_width=”80px”
       android:layout_height=”wrap_content”
       android:text=”发送”
       android:layout_x=”210px”
       android:layout_y=”260px”
       />
     </AbsoluteLayout>

    public class Server{//服务器端
需求独自编写翻译并在命令行形式下运转测试
     private static final int SE奥德赛VEKoleosPOOdysseyT = 5432一; //服务器端口 
     private static List<Socket> mClientList = new
ArrayList<Socket>(); //客户端连接
通过List来囤积全数连接进来的客户端的Socket对象(也可用CopyOnWriteArrayList来存款和储蓄)
     private ExecutorService mExecutor瑟维斯;  //线程池
必要为各样客户端都打开叁个线程   
     private ServerSocket mServerSocket;  //ServerSocket对象 
     public static void main(String[] args){ //main方法 开启服务器
      new Server();
     }
     public Server(){
      try{  
       mServerSocket = new ServerSocket(SERubiconVEBMWX三PO奥德赛T);//设置服务器端口  
       mExecutorService =
Executors.newCachedThreadPool();//创制多少个线程池
       System.out.println(“start…”);  
       Socket client = null;//用来暂时保存客户端连接的Socket对象
       while (true){   
        client = mServerSocket.accept(); //接收客户连接并添加到list中
        mClientList.add(client);   
        mExecutorService.execute(new
ThreadServer(client));//开启1个客户端线程
       }
      }catch (IOException e){
       e.printStackTrace();
      }
     }   
     static class ThreadServer implements
Runnable{//每一个客户端单独开启1个线程
      private Socket   mSocket;
      private BufferedReader mBufferedReader;
      private PrintWriter  mPrintWriter;
      private String   mStrMSG;

      public ThreadServer(Socket socket) throws IOException{
       this.mSocket = socket;
       mBufferedReader = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
       mStrMSG = “user:”+this.mSocket.getInetAddress()+” come total:” +
mClientList.size();
       sendMessage();
      }
      public void run(){
       try{
        while ((mStrMSG = mBufferedReader.readLine()) != null){
         if (mStrMSG.trim().equals(“exit”)){
          //当二个客户端退出时
          mClientList.remove(mSocket);
          mBufferedReader.close();
          mPrintWriter.close();
          mStrMSG = “user:”+this.mSocket.getInetAddress()+” exit total:”

  • mClientList.size();
              mSocket.close();
              sendMessage();
              break;
             }else{
              mStrMSG = mSocket.getInetAddress() + “:” + mStrMSG;
              sendMessage();
             }
            }
           }catch (IOException e){
            e.printStackTrace();
           }
          } 
          private void sendMessage() throws
    IOException{//发送消息给持有客户端
           System.out.println(mStrMSG);
           for (Socket client : mClientList){
            mPrintWriter = new PrintWriter(client.getOutputStream(),
    true);
            mPrintWriter.println(mStrMSG);
           }
          }
         }
        }
       
        public class Client贰{//供给独自编写翻译并在命令行情势下运行测试
         private static final int  PORT = 54321;
         private static ExecutorService exec =
    Executors.newCachedThreadPool();

     public static void main(String[] args) throws Exception{
      new Client2();
     }
     public Client2(){
      try{
       Socket socket = new Socket(“192.168.1.110”, PORT);
       exec.execute(new Sender(socket));
       BufferedReader br = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
       String msg;
       while ((msg = br.readLine()) != null){
        System.out.println(msg);
       }
      }catch (Exception e){
      }
     }    
     static class Sender implements
Runnable{//客户端线程获取控制台输入音信
      private Socket socket;
      public Sender(Socket socket){
       this.socket = socket;
      }
      public void run(){
       try{
        BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(socket.getOutputStream(),
true);
        String msg;
        while (true){
         msg = br.readLine();
         pw.println(msg);
         if (msg.trim().equals(“exit”)){
          pw.close();
          br.close();
          exec.shutdownNow();
          break;
         }
        }
       }catch (Exception e){
        e.printStackTrace();
       }
      }
     } 
    }
   
    public class Activity0一 extends Activity{//客户端,
客户端必要与服务器始终维持通讯状态
只顾:因Android是线程安全的,所以不能够一向在线程中更新视图,需使用Handler来更新视图
           当点击”登陆“按钮时,连接服务器,并得到需求操作的流,
点击”发送”按钮时取出输入框中的始末发送向服务器,由服务器发送给每种客户端

     private final String  DEBUG_TAG = “Activity01”;     
     private static final String SERVERIP =
“192.168.1.110”;//服务器IP、端口
     private static final int SERVERPORT = 54321;
     private Thread mThread = null;
     private Socket    mSocket  = null;
     private Button    mButton_In = null;
     private Button    mButton_Send= null;
     private EditText   mEditText01  = null;
     private EditText   mEditText02  = null;
     private BufferedReader  mBufferedReader = null;
     private PrintWriter mPrintWriter = null;
     private  String mStrMSG = “”;

     public void onCreate(Bundle savedInstanceState){
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
 
      mButton_In = (Button)findViewById(R.id.Button_In);
      mButton_Send = (Button)findViewById(R.id.Button_Send);
      mEditText01=(EditText)findViewById(R.id.EditText01);
      mEditText02=(EditText)findViewById(R.id.EditText02);
 
      mButton_In.setOnClickListener(new OnClickListener(){//登陆按钮
       public void onClick(View v){
        try {    
         mSocket = new Socket(SE卡宴VECR-VIP, SE宝马X5VERPOCR-VT); //连接服务器    
         mBufferedReader = new Buffered里德r(new
InputStreamReader(mSocket.getInputStream()));//取得输入、输出流
         mPrintWriter=new PrintWriter(mSocket.getOutputStream(),
true);  
        }catch (Exception e) {
         Log.e(DEBUG_TAG, e.toString());
        }
       }
      });
      mButton_Send.setOnClickListener(new
OnClickListener(){//发送音信按钮
       public void onClick(View v){
        try {
         String str = mEditText02.getText().toString() +
“\n”;//取得编辑框中大家输入的内容
         mPrintWriter.print(str);//发送给服务器
         mPrintWriter.flush();
        }catch (Exception e) {
         Log.e(DEBUG_TAG, e.toString());
        }
       }
      });
      mThread = new Thread(mRunnable);
      mThread.start();
     }
     private Runnable mRunnable = new Runnable() {
//线程:监听服务器发来的信息
      public void run(){
       while (true){
        try{
         if ( (mStrMSG = mBufferedReader.readLine()) != null ){     
          mStrMSG+=”\n”;//新闻换行
          mHandler.sendMessage(mHandler.obtainMessage());// 发送消息
         }    
        }catch (Exception e){
         Log.e(DEBUG_TAG, e.toString());
        }
       }
      }
     };
     Handler mHandler = new Handler() {         
      public void handleMessage(Message msg){          
       super.handleMessage(msg);//接受新闻 刷新
       try{     
        m艾德itText0一.append(mStrMSG); //将聊天记录添加进去  
       }catch (Exception e){                    
        Log.e(DEBUG_TAG, e.toString());         
       }         
      }        
     };
    }

第6有个别 网络通信的国语乱码难点
  要想化解Java华语乱码难题,需通晓如下内容:
   字符:是文字与符号的总称,包含文字、图形符号、数学符号等。
   字符集:正是一组抽象字符的汇集。
字符集平常和1种具体的语言文字对应起来,该文字中具有字符只怕超越四分之二字符就构成了该字符集。
比如说英文字符集、繁体汉字字符集、日文字符集等。
  
字符编码:总结机要拍卖各个字符,就必要将字符和2进制内码对应起来,那种对应关系正是字符编码。
要分明编码首先要明确字符集,并将字符集内的字符排序,然后和贰进制数字对应起来。
听大人说字符集内字符的多少,鲜明用多少个字节来编码。
     ASCII编码是近期用得最广的字符集及编码。
    
Unicode编码是电脑上运用的字符编码。UTF-八正是Unicode编码的贯彻形式。
     GB231二字集是简体字集
     BIG5字集湖南繁体字集
     GBK字集是简繁字集
    
GB18030是国家制定的3个强制性大字集标准,它的生产使汉字有了统1的科班。
     Linux系统暗中同意使用的是ISO-885⑨-1编码
     Win32体系私下认可使用的是GB231二编码
   互联网通讯中,发生乱码的缘由根本是通讯进程中应用了不相同的编码方式:
如:服务器中的编码格局、传输进程中的编码方式、传输到达终点设备的编码方式。
因此在传输进程中足足必要三遍编码转换。
先是从服务器编码转换为互联网编码,再从互联网编码转换为终端设备编码。
在更换进度中生出任何景况都恐怕引起编码混乱,
  
   能够透过二种情势来防止编码混乱:
    第二种:由于多数终端设备都帮助Unicode字符集,
于是在接连网页时,大家盼望网页数据在网络传输时选拔UTF-八格局传输,
诸如此类就能够将UTF-⑧转换来Unicode字符集了。
     
上边为大家将通讯进度中拿走的流先转换为字节,然后再将字节按GB231二的主意开始展览转换获得字符串。
      InputStream is = conn.getInputStream();
      BufferedInputStream bis =new.BufferedInputStream(is);
      byte bytearray[] = new byte[1024];
      int current = -1;
      int i = 0;
      while((current = bis.read()) != -1){
       bytearray[i] = (byte) current;
       i++;
      }
      resultData = new
String(bytearray,”GB231贰”);//resultData字符串便可显示中文效果
    第二种:在数码传输进度中应用ISO-885玖-一字符集,
如此正是直接选取ASCII编码方式,当然在传递到终端设备时,必要将其数额反转才能符合规律显示。
      下边将三个字符串按ISO-8859-1字符集举行转移。
      public static String FormatStr(String str){
       if(str = null||str.length() ==0){
        return “”;
       }
       try{
        return new
String(str.getBytes(“ISO-885九-1″),”bgk”);//使用getBytes(“编码方式”)
对汉字举办重编码,
获得它的字节数组。再使用new String(Bytes[],”解码格局”)
                      来对字节数组实行相应的解码。
其实只要精晓了如几时候理应编码,何时应该解码,怎么编码、解码就不怕普通话乱码难点了。
       }catch(UnsupportedEncodingException ex){
        return str;
       }
      }
     
第9部分 WebKit应用 
   Android 浏览器的内核是Webkit引擎,WebKit的前身是KDE小组的KHTML.
   WebKit
    是三个开源浏览器网页排版引擎。与之相应的内燃机有Gecko和Trident等。
    Web基特 由三个模块组成:
    WebKit       整个项目标称号
    JavaScriptCore JavaScrip解释器
    WebCore  
整个项指标基本,用来完毕Render引擎,解析Web页面,生成1个DOM树和八个Render树。
    WebKit的解析进度:
     一、CU汉兰达L拿到网址的stream。
     2、解析划分字符串。
     三、通过DOM Builer按法定的HTML规范生成DOM树。
     4、即便有Javascript,JSEngine就经过ECMA-26贰正式周到DOM树。
    
五、把DOM传给LayoutEngine举行布局,假使有CSS样式,就经过CSSParser解析。
     陆、最终Rendering渲染出来。
   WebView
    WebView控件是WebKit类中越发用来浏览网页的控件。
    其应用须求在XML文件中如下设计:
    <WebView
     android:id=”@+id/WebView01″
     android:layout_width=”fill_parent”
     android:layout_height=”fill_parent” 
     android:layout_weight=”1″
     />
    然后须要在程序代码中间转播载这几个控件
,并设置其颜色、字体、要访问的网站(也可在XML文件中装置)。
    通过loadUrl方法设置当前WebView须求拜访的网址代码如下:
    mWebView= (WebView)findViewById(R.id.WebView01);
    mWebView.loadUrl(“http://www.google.com/“);
   WebSettings
   
在Android中能够透过WebSettings来设置Web基特的局地质量、状态等。在创设WebView时,系统有三个暗中同意的装置,能够经过WebView.getSettings来获得如下:
    WebSettings webSettings =
mWebView.getSetting();//得到mWebView的WebSettings对象
    WebSettings和WebView
都在同等生命周期中存在,当WebView被销毁后,借使再利用WebSettings则会抛出IllegalStateException格外。
   
下为时设置有个别常用属性、状态的章程。将上面的set改为get即可获取WebView的一些质量和情景。
     setAllowFileAccess   运营或禁止WebView访问文件数量
     setBlockNetworkImage  是或不是出示图像
     setBuiltInZoomControls  设置是还是不是协理缩放
     setCacheMode    设置缓冲情势
     setDefaultFontSize   设置私下认可的字体大小
     setDefaultTextEncodingName 设置在解码时使用的暗中同意编码
     setFixedFontFamily   设置固定使用的书体
     setJavaScriptEnabled  设置是或不是帮忙JavaScript
     setLayoutAlgorithm   设置布局格局
     setLightTouchEnabled  设置用鼠标激活被挑选
     setSupportZoom    设置是还是不是帮忙定焦
   WebViewClient
    在先后中得以用WebViewClient来自定义网页浏览程序。
   
此类专门救助WebView处理各个通告,请求等事件的类。能够经过WebView的setWebViewClient方法来创设3个WebViewClient对象。
    WebViewClient常用艺术:
     doUpdateVisitedHistory   更新历史记录
     onFormResubmission    应用程序重新请求网页数据
     onLoadResource     加载钦赐地址提供的财富
     onPageFinished     网页加载完结
     onPageStarted     网页起初加载
     onReceivedError     报告错误新闻
     onScaleChanged     WebView发生改变
     shouldOverrideUrlLoading  控制新的一连在时下WebView中开辟
   
大家能够覆盖这么些艺术来支持WebView浏览网页.如下:大家设置覆盖shouldOverrideUrlLoading方法。
     public boolean shouldOverrideUrlLoading(WebView view ,String
url){
      view.loadUrl(url);//设置访问的网站
      ruturn true;
     }
   WebChromeClient
   
在Android中经过WebChromeClient专门来援救WebView处理Javascript的对话框、网址图标、网址Title、加载进度等。
    WebChromeClient中常用艺术
     onCloseWindow  关闭WebView
     onCreateWindow  创建WebView
     onJsAlert   处理Javascript中的Alert对话框
     onJsConfirm   处理Javascript中的Confirm对话框
     onJsPrompt   处理Javascript中的Prompt对话框
     onProgressChanged 加载进程条改变
     onReceivedIcon  网页图标改动
     onReceivedTitle  网页Title更改
     onRequestFocus  WebView突显核心
    下边来贯彻onReceiveTitle方法,用于转移应用程序的Title 代码如下:
     public void onReceivedTitle(WebView view,String title){
      Activity01.this.setTitle(title);
      super.onReceivedTitle(view,title);
     }
   下例为对下面知识的汇总选用。
   prom_dialog.xml文件
   <?xml version=”1.0″ encoding=”utf-8″?>
   <LinearLayout
xmlns:android=”http://schemas.android.com/apk/res/android
    android:gravity=”center_horizontal”
    android:orientation=”vertical”
    android:layout_width=”fill_parent”
    android:layout_height=”wrap_content”
    >
    <TextView
     android:id=”@+id/TextView_PROM”
     android:layout_width=”fill_parent”
     android:layout_height=”wrap_content”/>
    <EditText
     android:id=”@+id/EditText_PROM”
     android:layout_width=”fill_parent”
     android:layout_height=”wrap_content”
     android:selectAllOnFocus=”true”
     android:scrollHorizontally=”true”/>
   </LinearLayout>
   main.xml文件
   <?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”
    >
    <LinearLayout
     android:orientation=”horizontal”
     android:layout_width=”fill_parent”
     android:layout_height=”fill_parent”
     android:animationCache=”true”
     android:layout_weight=”9″>
     <EditText
      android:id=”@+id/EditText01″
      android:layout_width=”wrap_content”
      android:layout_weight=”9″
      android:layout_height=”wrap_content”
      android:text=”请输入网站”/>
     <Button
      android:id=”@+id/Button01″
      android:layout_width=”wrap_content”
      android:layout_weight=”1″
      android:layout_height=”wrap_content”
      android:text=”连接” />
    </LinearLayout>
    <WebView
     android:id=”@+id/WebView01″
     android:layout_width=”fill_parent”
     android:layout_height=”fill_parent” 
     android:layout_weight=”1″
     />
   </LinearLayout>
  
   public class Activity01 extends Activity{
    private final String DEBUG_TAG = “Activity01”;
    private Button 
mButton;//界面中运用艾德itText来输入网址,用Button来承认连接,用WebView来显示网页内容。
    private EditText mEditText;
    private WebView  mWebView;

    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
     mButton = (Button) findViewById(R.id.Button01);
     mEditText = (EditText) findViewById(R.id.EditText01);
     mWebView = (WebView) findViewById(R.id.WebView01);
 
     WebSettings webSettings =
mWebView.getSettings();//设置帮衬JavaScript脚本 
     webSettings.setJavaScriptEnabled(true); 
     webSettings.setAllowFileAccess(true);//设置能够访问文件 
     webSettings.setBuiltInZoomControls(true);//设置帮忙缩放
 
     mWebView.setWebViewClient(new WebViewClient(){ //设置WebViewClient
来协理WebView处理局地风浪
      public boolean shouldOverrideUrlLoading(WebView view, String url)
{  
       view.loadUrl(url);  
       return true;  
      } 
      public void onPageFinished(WebView view, String url) {
       super.onPageFinished(view, url);
      }
      public void onPageStarted(WebView view, String url, Bitmap
favicon) {
       super.onPageStarted(view, url, favicon);
      }
     }); 
     mWebView.setWebChromeClient(new
WebChromeClient(){//设置WebChromeClient
来辅助WebView处理JavaScripte对话框 
      public boolean onJsAlert(WebView view, String url, String
message,final JsResult result) {//处理javascript中的alert
       //创设三个Builder来显示网页中的对话框
       Builder builder = new Builder(Activity01.this);
       builder.setTitle(“提醒对话框”);
       builder.setMessage(message);
       builder.setPositiveButton(android.R.string.ok,
        new AlertDialog.OnClickListener() {
         public void onClick(DialogInterface dialog, int which)
{       
         
esult.confirm();//点击确定按钮之后,继续执行网页中的操作。通过confirm和cancel方法将我们的操作传递给Javascript处理
         }
        });
       builder.setCancelable(false);
       builder.create();
       builder.show();
       return true;
      }; 
      public boolean onJsConfirm(WebView view, String url, String
message,final JsResult result) {//处理javascript中的confirm
       Builder builder = new Builder(Activity01.this);
       builder.setTitle(“带选拔的对话框”);
       builder.setMessage(message);
       builder.setPositiveButton(android.R.string.ok,
        new AlertDialog.OnClickListener() {
         public void onClick(DialogInterface dialog, int which) {
         
result.confirm();//通过confirm和cancel方法将我们的操作传递给Javascript处理
         }
        });
       builder.setNegativeButton(android.R.string.cancel,
        new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog, int which) {
         
result.cancel();//通过confirm和cancel方法将我们的操作传递给Javascript处理
         }
        });
       builder.setCancelable(false);
       builder.create();
       builder.show();
       return true;
      };
      public boolean onJsPrompt(WebView view, String url, String
message,
       String defaultValue, final JsPromptResult result)
{//处理javascript中的prompt,message为网页中对话框的唤醒内容,defaultValue在未曾输入时,私下认可展现的始末   
       final LayoutInflater factory =
LayoutInflater.from(Activity0一.this);//自定义三个带输入的对话框由TextView和艾德itText构成
       final View dialogview = factory.inflate(R.layout.prom_dialog,
null);   
       ((TextView)
dialogview.findViewById(R.id.TextView_PROM)).setText(message);//设置TextView对应网页中的提醒消息  
       ((EditText)
dialogview.findViewById(R.id.EditText_PROM)).setText(defaultValue);//设置艾德itText对应网页中的输入框
   
       Builder builder = new Builder(Activity01.this);
       builder.setTitle(“带输入的对话框”);
       builder.setView(dialogview);
       builder.setPositiveButton(android.R.string.ok,
        new AlertDialog.OnClickListener() {
         public void onClick(DialogInterface dialog, int which)
{      
          String value = ((EditText)
dialogview.findViewById(R.id.EditText_PROM)).getText().toString();//点击明确未来,取得输入的值,传给网页处理
         
result.confirm(value);//通过confirm和cancel方法将大家的操作传递给Javascript处理
         }
        });
       builder.setNegativeButton(android.R.string.cancel,
        new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog, int which) {
         
result.cancel();//通过confirm和cancel方法将大家的操作传递给Javascript处理
         }
        });
       builder.setOnCancelListener(new
DialogInterface.OnCancelListener() {
        public void onCancel(DialogInterface dialog) {
        
result.cancel();//通过confirm和cancel方法将大家的操作传递给Javascript处理
        }
       });
       builder.show();
       return true;
      };  
      public void onProgressChanged(WebView view, int newProgress)
{//设置网页加载的进度条
      
Activity01.this.getWindow().setFeatureInt(Window.FEATURE_PROGRESS,
newProgress * 100);
       super.onProgressChanged(view, newProgress);
      }  
      public void onReceivedTitle(WebView view, String title)
{//设置应用程序的标题title
       Activity01.this.setTitle(title);
       super.onReceivedTitle(view, title);
      }
     }); 
     mButton.setOnClickListener(new
OnClickListener(){//连接按钮事件监听
      public void onClick(View v){
       try {    
        String url =
m艾德itText.getText().toString();//取得编辑框中大家输入的始末       
        if ( U奇骏LUtil.isNetworkUrl(url) ){
//判断输入的内容是或不是网站        
         mWebView.loadUrl(url);//装载网站
        }else{
         m艾德itText.setText(“输入网站错误,请重新输入”);
        }
       }catch (Exception e){
        Log.e(DEBUG_TAG, e.toString());
       }
      }
     });
    }
    public boolean onKeyDown(int keyCode, KeyEvent event){
     if ((keyCode == KeyEvent.KEYCODE_BACK) &&
mWebView.canGoBack()){//当大家按再次来到键时
能够通过goBack和goForward方法来设置其发展和滞后,但在动用在此之前大家透过
                    
canGoBack和canGoForward方法来检测是或不是可未来退和进化。
      mWebView.goBack();//重临前一个页面
       return true;
     }
     return super.onKeyDown(keyCode, event);
    } 
   }
  
   WebView和Javascript相互调用
   
下例为兑现了WebView和Javascript怎样相互调用,该例达成了从Android应用中调出个人资料,然后通过Javascript显示出来。
   main.xml
   <?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”
     >
     <WebView
      android:id=”@+id/WebView01″
      android:layout_width=”fill_parent”
      android:layout_height=”fill_parent”/>
    </LinearLayout>

   public class Activity01 extends Activity{
    private WebView mWebView;
    private PersonalData mPersonalData;
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
     mPersonalData = new PersonalData();
     mWebView = (WebView)this.findViewById(R.id.WebView01);
 
    
mWebView.getSettings().setJavaScriptEnabled(true);//设置援救JavaScript
     mWebView.addJavascriptInterface(this,
“PersonalData”);//把本类的一个实例添加到js的全局对象window中,那样就足以行使window.PersonalData来调用它的主意 
    
mWebView.loadUrl(“http://www.cnblogs.com/freeliver54/admin/file:///android_asset/PersonalData.html%22);//加载网页。
                   
在Java代码中经过WebView.loadUrl(“javascript:方法名”);能够平昔调用Javascript方法
                    为了让WebViwe从Apk文件中加载assets,Android
SDK提供了一个Schema,前缀
                   
为”http://www.cnblogs.com/freeliver54/admin/file:///android_asset/“。当WebView碰到Schema,就去当前包中的Assets目录中找内容
    }
    public PersonalData
getPersonalData(){//在js脚本中调用获得PersonalData对象
     return mPersonalData;
    } 
    class
PersonalData{//js脚本中调用展现的材质。定义一个PersonalData类,用来保存个人资料,并且定义得到这个数量的成员函数,供Javascript调用
     String  mID;
     String  mName;
     String  mAge;
     String  mBlog;
     public PersonalData(){
      this.mID=”123456789″;
      this.mName=”Android”;
      this.mAge=”100″;
      this.mBlog=”http://yarin.javaeye.com/“;
     }
     public String getID(){
      return mID;
     }
     public String getName(){
      return mName;
     }
     public String getAge(){
      return mAge;
     }
     public String getBlog(){
      return mBlog;
     }
    }
   }
  
通过下面的起首化WebView后,在Javascript中就足以用window.PersonalData.getPersonalData()来博取Java对象。
   下边是在Javascript拜访Android应用的代码。
   assets.test.js文件
    window.onload = function(){
     var personaldate =
window.PersonalData.getPersonalData();//取得java对象
     if(personaldate){
      var Personaldate = document.getElementById(“Personaldate”);
      pnode = document.createElement(“P”);
      tnode =
document.createTextNode(“ID:”+personaldate.getID());//通过Java对象访问数据
      pnode = appendChild(tnode);
      Personaldata.appendChild(pnode);
     
      pnode = document.createElement(“P”);
      tnode =
document.createTextNode(“Name:”+personaldate.getName());//通过Java对象访问数据
      pnode = appendChild(tnode);
      Personaldata.appendChild(pnode);
     
      pnode = document.createElement(“P”);
      tnode =
document.createTextNode(“Age:”+personaldate.getAge());//通过Java对象访问数据
      pnode = appendChild(tnode);
      Personaldata.appendChild(pnode);
     
      pnode = document.createElement(“P”);
      tnode =
document.createTextNode(“Blog:”+personaldate.getBlog());//通过Java对象访问数据
      pnode = appendChild(tnode);
      Personaldata.appendChild(pnode);
     }
    }
第8局地 WiFi—Wireless Fidelity
   WiFi又称80二.11b标准,最大亮点传输速度高。
   WiFi操作的部分常见类和接口
    ScanResult
    
重要用来描述已经济检察测出的接入点,包蕴接入点的地方、名称、身份注明、频率、信号强度等新闻。
    WifiConfiguration
     WiFi互联网的配置,包涵安全安插等
    WifiInfo
    
WiFi有线连接的描述,包蕴接入点、网络连接状态、隐藏的接入点、IP地址、连接速度、MAC地址、网络ID、非确定性信号强度等新闻。
    WifiManager
     包涵了保管WiFi连接的大部API,如下内容:
     
已经布署好的互连网清单。那些清单能够查阅和修改,而且能够修改个别记录的质量。
     
当连接中有移动的Wi-Fi互连网时,能够创设或关闭那么些一连,并且能够查询有关互连网状态的动态消息。
      对接入点的扫描结果包涵充裕的新闻来支配必要与哪些接入点建立连接。
      还定义了更仆难数常量来表示Wi-Fi状态的变动。
    WifiManager.WifiLock
    
用户1段时间未有别的操作时,WiFi就会自行关闭,大家得以由此WifiLock来锁定WiFi互联网,使其直接保持接二连三,直到锁定被假释。
    
当有多个应用程序时或者会有多少个WifiLock,在有线电装置中必须保障别的三个使用中都未曾选拔WifiLock时,才方可关闭它。
    
在利用WiFi锁以前,必须明确应用须要WiFi的连片,也许能够在移动网络下工作。
     WiFi锁不能够超越客户端的Wi-Fi Enabled设置,也不曾飞行形式。
     如下代码可获得WifiManager对象,可利用这一个目的来操作WiFi连接
      WifiManager wifiManager =
(WifiManager)getSystemService(Context.WIFI_SERVICE);
      如下为WifiManager的常用方法:
       addNetwork    添加1个计划好的网络连接
       calculateSignalLevel 总括非数字信号强度
       compareSignalLevel  相比较七个时域信号的强度
       createWifiLock   创制贰个Wifi锁
       disableNetwork   撤消一个配备好的网络,固然其不可用
       disconnect    从接入点断开
       enableNetwork   允许钦定的互联网连接
       getConfiguredNetworks 获得客户端具备曾经配备好的互连网列表
       getConnectionInfo  获得正在使用的连天的动态新闻
       getDhcpInfo    获得最后三遍成功的DHCP请求的DHCP地址
       getScanResults   获得被扫描到的接入点
       getWifiState   获得可用WiFi的气象
       isWifiEnabled   获得WiFi是不是可用
       pingSupplicant   检查客户端对请求的感应
       reassociate    从如今接入点重新连接
       removeNetwork   从曾经安插好的网络列表中去除钦命ID的互联网
       saveConfiguration  保存当前安顿好的互连网列表
       setWifiEnabled   设置WiFi是或不是可用
       startScan    扫描存在的接入点
       updateNetwork   更新已经布署好的网络
  
例:下例中的WifiAdmin须求打开(关闭)WIFI、锁定(释放)WifiLock、创造WifiLock、取得配置好的网络、扫描、连接、断开、获取网络连接的音讯。
   因WiFi与装备有关所以需在真机上才能看到成效。
   public class Activity01 extends Activity{
    private WifiManager wifiManager;
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
    }
   }
   public class WifiAdmin{
    private WifiManager mWifiManager;//定义WifiManager对象
    private WifiInfo mWifiInfo;//定义WifiInfo对象
    private List<ScanResult> mWifiList;//扫描出的互连网连接列表
    private List<WifiConfiguration>
mWifiConfiguration;//互连网连接列表
    WifiLock mWifiLock;//定义三个WifiLock
    public  WifiAdmin(Context context){//构造器 
     mWifiManager = (WifiManager)
context.getSystemService(Context.WIFI_SERVICE);//取得WifiManager对象
     mWifiInfo = mWifiManager.getConnectionInfo();//取得WifiInfo对象
    }
    public void OpenWifi(){//打开WIFI
     if (!mWifiManager.isWifiEnabled()){
      mWifiManager.setWifiEnabled(true);  
     }
    }
    public void CloseWifi(){//关闭WIFI
     if (!mWifiManager.isWifiEnabled()){
      mWifiManager.setWifiEnabled(false);
     }
    }
    public void AcquireWifiLock(){//锁定WifiLock
     mWifiLock.acquire();
    }
    public void ReleaseWifiLock(){//解锁WifiLock 
     if (mWifiLock.isHeld()){//判断时候锁定
      mWifiLock.acquire();
     }
    }
    public void CreatWifiLock(){ //创造1个WifiLock
     mWifiLock = mWifiManager.createWifiLock(“Test”);
    }
    public List<WifiConfiguration>
GetConfiguration(){//获得铺排好的网络
     return mWifiConfiguration;
    }
    public void ConnectConfiguration(int
index){//钦赐计划好的互联网进行延续
     if(index >
mWifiConfiguration.size()){//索引大于配置好的互连网索引重回
      return;
     } 
     mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,
true);//连接配置好的钦命ID的互联网
    }
    public void StartScan(){
     mWifiManager.startScan();
     mWifiList = mWifiManager.getScanResults();//获得扫描结果 
     mWifiConfiguration =
mWifiManager.getConfiguredNetworks();//获得计划好的网络连接
    }
    public List<ScanResult> GetWifiList(){//得到网络列表
     return mWifiList;
    }
    public StringBuilder LookUpScan(){//查看扫描结果
     StringBuilder stringBuilder = new StringBuilder();
      for (int i = 0; i < mWifiList.size(); i++){
       stringBuilder.append(“Index_”+new Integer(i + 1).toString() +
“:”);
      
//将ScanResult音信转换来一个字符串包,当中把包含:BSSID、SSID、capabilities、frequency、level
       stringBuilder.append((mWifiList.get(i)).toString());
       stringBuilder.append(“\n”);
      }
      return stringBuilder;
    }
    public String GetMacAddress(){//得到MAC地址
     return (mWifiInfo == null) ? “NULL” : mWifiInfo.getMacAddress();
    }
    public String GetBSSID(){//获得接入点的BSSID
     return (mWifiInfo == null) ? “NULL” : mWifiInfo.getBSSID();
    }
    public int GetIPAddress(){//得到IP地址
     return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
    }
    public int GetNetworkId(){//得到再而三的ID
     return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
    }
    public String GetWifiInfo(){//获得WifiInfo的保有新闻包
     return (mWifiInfo == null) ? “NULL” : mWifiInfo.toString();
    }
    public void AddNetwork(WifiConfiguration wcg){//添加三个互连网并再而三
     int wcgID = mWifiManager.addNetwork(wcg);
     mWifiManager.enableNetwork(wcgID, true);
    }
    public void DisconnectWifi(int netId){//断开钦定ID的网络
     mWifiManager.disableNetwork(netId);
     mWifiManager.disconnect();
    }
   }
   AndroidManifest.xml文件 最后索要在此文件中对权力举行宣示
    <uses-permission
android:name=”android.permission.ACCESS_WIFI_STATE”></uses-permission>
    <uses-permission
android:name=”android.permission.ACCESS_CHECKIN_PROPERTIES”></uses-permission>
    <uses-permission
android:name=”android.permission.WAKE_LOCK”></uses-permission>
    <uses-permission
android:name=”android.permission.INTERNET”></uses-permission>
    <uses-permission
android:name=”android.permission.CHANGE_WIFI_STATE”></uses-permission>
    <uses-permission
android:name=”android.permission.MODIFY_PHONE_STATE”></uses-permission>
   
第七有的 蓝牙( Bluetooth® )
  
Bluetooth是一种短距离的有线连接技术标准的代称,蓝牙( Bluetooth® )的面目内容正是起家通用无线电空中接口及其控制软件的公然规范。
  
蓝牙5.0采纳分散式互联网布局以及快调频和短包技术,支持点对点以及多对点通讯,
工作在全球通用的二.肆GHz
ISM(即工业、科学、文学)频段,其数量速率为1Mbps,采取时分双工传输方案。
  
蓝牙5.0协议分4层:即宗旨协议层、电缆替代协议层、电话控制协议层、选拔别的的协议层。
   Android 2.0 即API Level等级为伍或上述版本才含有蓝牙( Bluetooth® )成效
   蓝牙5.0的类和接口位于android.bluetooth包中,有如下功能:
    BluetoothAdapter   蓝牙( Bluetooth® )适配器(代表本地Bluetooth适配器)
    蓝牙( Bluetooth® )Class    Bluetooth类(首要不外乎劳动和设施)
    蓝牙伍.0( Bluetooth® )Class.Device  Bluetooth设备类
    BluetoothClass.Device.Major Bluetooth设备管理
    蓝牙( Bluetooth® )Class.Service  有关蓝牙5.0服务的类
    BluetoothDevice    蓝牙5.0设备(主要指远程蓝牙5.0设备)
    BluetoothServerSocket  监听蓝牙五.0连接的类
    Bluetooth( Bluetooth® )Socket    Bluetooth连接类
   要使用蓝牙( Bluetooth® )API必供给在AndroidManifest.xml中声称权限代码如下:
    <uses-sdk android:minSdkVersion=”5″ />//API等级为5
    <uses-permission android:name=”android.permission.BLUETOOTH”
/>//蓝牙( Bluetooth® )权限
    <uses-permission
android:name=”android.permission.BLUETOOTH_ADMIN”
/>//Bluetooth管理、操作
    <uses-permission
android:name=”android.permission.READ_CONTACTS”/>//读取联系人
   要使用蓝牙( Bluetooth® )必须先拿走蓝牙( Bluetooth® )适配器 代码如下:
    BluetoothAdapter  _bluetooth =
Bluetooth( Bluetooth® )Adapter.getDefaultAdapter();//通过getDefaultAdapter()方法得到本地蓝牙五.0适配器,要博得远程的用蓝牙( Bluetooth® )Device类。
  
如何开辟、关闭本地Bluetooth和哪些才能使别的设施能够寻找到祥和的设备?如下:
    首先定义五个常量,分别代表呼吁打开和请求能够被寻找代码如下:
     private static final int REQUEST_ENABLE;//请求打开蓝牙( Bluetooth® )
     private static final int REQUEST_DISCOVERABLE;//请求能够被寻找
    一、请求开启蓝牙( Bluetooth® )
     Intent enabler = new
Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);//请求系统允许用户打开Bluetooth
     startActivityForResult(enabler, REQUEST_ENABLE);
    二、请求能够被寻找
     Intent enabler = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);//请求系统允许Bluetooth设备被搜寻
     startActivityForResult(enabler, REQUEST_DISCOVERABLE);
      蓝牙伍.0Adapter类中别的动作常量
       ACTION_DISCOVERY_FINISHED  已经做到搜索
       ACTION_DISCOVERY_STAPAJEROTED  已经上马搜索蓝牙5.0设备
       ACTION_LOCAL_NAME_CHANGED  更改蓝牙( Bluetooth® )名字
       ACTION_REQUEST_DISCOVERABLE  请求能够被搜寻
       ACTION_REQUEST_ENABLE   请求开启蓝牙( Bluetooth® )
       ACTION_SCAN_MODE_CHANGED  描述形式已改成
       ACTION_STATE_CHANGED   状态已改变
    三、打开蓝牙( Bluetooth® )
     _bluetooth.enable();//使用BluetoothAdapter类中的enable方法
    四、关闭蓝牙( Bluetooth® )
     _bluetooth.disable();//使用BluetoothAdapter类中的diable方法
      蓝牙( Bluetooth® )Adapter中的常用方法
       cancelDiscovery   撤废当前设备搜索进度
       checkBlutoothAddress
检查评定蓝牙5.0地址是还是不是科学。如”00:4三:A8:二三:十:F0″字母必须是大写
       disable     关闭Bluetooth适配器
       enable     打开蓝牙5.0适配器
       getAddress    取得地点蓝牙伍.0的硬件适配器地址
       getDefaultAdapter  得到默许的Bluetooth适配器
       getName     获得蓝牙5.0的名字
       getRemoteDevice   取得钦点蓝牙5.0硬件地址的蓝牙( Bluetooth® )Device对象
       getScanMode    得到扫描方式
       getState    获得气象
       isDiscovering   是或不是同意被搜寻
       isEnabled    是或不是打开
       setName     设置名字
       startDiscovery   起始搜索
    5、搜索Bluetooth设备
     搜索远程蓝牙5.0设备亟需采用Bluetooth( Bluetooth® )Device类
    
首先应用Bluetooth( Bluetooth® )Adapter类的getRemoteDevice方法来赢得三个点名地点的蓝牙5.0( Bluetooth® )Device
     蓝牙伍.0Device类实际是1个蓝牙5.0硬件地址薄,该类对象是不可改变的。
其操作都以远程Bluetooth硬件地址使用蓝牙( Bluetooth® )Adapter来成立三个BluetoothDevice对象。

   public class DiscoveryActivity  extends
ListActivity{//此类为寻找Bluetooth的类
    private Handler _handler = new Handler();
    private BluetoothAdapter _bluetooth =
蓝牙五.0( Bluetooth® )Adapter.getDefaultAdapter();//取得暗中同意的蓝牙5.0适配器
    private List<BluetoothDevice> _devices = new
ArrayList<蓝牙Device>();// 用List来储存搜索到的蓝牙( Bluetooth® )设备
    private volatile boolean  _discoveryFinished;//是还是不是成功搜索
    private Runnable _discoveryWorkder = new Runnable() {
     public void run() {
      _bluetooth.startDiscovery();//早先探寻
      for (;;) {
       if (_discoveryFinished) {
        break;
       }
       try {
        Thread.sleep(100);
       } catch (InterruptedException e){}
      }
     }
    };
    private BroadcastReceiver _foundReceiver = new
布罗兹castReceiver(){// 接收器 当搜索蓝牙五.0设备完结时调用
     public void onReceive(Context context, Intent intent) {
      BluetoothDevice device =
intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);//从intent中获得搜索结果数据
      _devices.add(device);//将结果添加到列表中
      showDevices();//展现列表
     }
    };
    private BroadcastReceiver _discoveryReceiver = new
BroadcastReceiver() {
     public void onReceive(Context context, Intent intent) {
      /* 卸载注册的收受器 */
      unregisterReceiver(_foundReceiver);
      unregisterReceiver(this);
      _discoveryFinished = true;
     }
    };
    protected void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     
getWindow().setFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND,
WindowManager.LayoutParams.FLAG_BLUR_BEHIND);
      setContentView(R.layout.discovery);
      if (!_bluetooth.isEnabled()){//假设蓝牙5.0适配器未有打开,则结果
       finish();
       return;
      }
      /* 注册接收器 */
      IntentFilter discoveryFilter = new
IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);//一搜索以成就 
程序时通过线程来支配Bluetooth设备的摸索的(startDiscovery)
                            
当搜索进程中触发一、二八个接收器就直接传送给接收器进性保存
                             注意:搜索蓝牙5.0设备流水生产线为:
                            
取得蓝牙五.0适配器(getDefaultAdapter)—初步探寻—
                            
搜索完毕(ACTION_DISCOVERY_FINISHED)卸载BroadcastReceiver
                            
—发现设备(ACTION_FOUND)—取得设备(EXTRA_DEVICE)
      registerReceiver(_discoveryReceiver, discoveryFilter);
      IntentFilter foundFilter = new
IntentFilter(BluetoothDevice.ACTION_FOUND);//贰发现设备
      registerReceiver(_foundReceiver, foundFilter);
      SamplesUtils.indeterminate(DiscoveryActivity.this, _handler,
“Scanning…”, _discoveryWorkder, new OnDismissListener()
{//彰显二个对话框,正在搜索Bluetooth设备
       public void onDismiss(DialogInterface dialog){
        for (; _bluetooth.isDiscovering();){
         _bluetooth.cancelDiscovery();
        }
        _discoveryFinished = true;
       }
      }, true);
    }
    protected void showDevices(){//展现列表
最终将保留在List中的蓝牙( Bluetooth® )( Bluetooth® )Device彰显在2个ListView中
     List<String> list = new ArrayList<String>();
      for (int i = 0, size = _devices.size(); i < size; ++i){
       StringBuilder b = new StringBuilder();
       BluetoothDevice d = _devices.get(i);
       b.append(d.getAddress());
       b.append(‘\n’);
       b.append(d.getName());
       String s = b.toString();
       list.add(s);
      }
     final ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this, android.R.layout.simple_list_item_1,
list);
     _handler.post(new Runnable() {
      public void run(){
       setListAdapter(adapter);
      }
     });
    }
    protected void onListItemClick(ListView l, View v, int position,
long id){
     Intent result = new Intent();
     result.putExtra(BluetoothDevice.EXTRA_DEVICE,
_devices.get(position));
     setResult(RESULT_OK, result);
     finish();
    }
   }
   BluetoothSocket服务器与客户端
   
蓝牙5.0服务器端正是通过注册1个持盛名称和唯1识别的UUID号的Bluetooth( Bluetooth® )ServerSocket,然后径直监听客户端(BluetoothSocket)的央浼,并作出相应处理。
    如何注册蓝牙伍.0服务器代码:
     private BluetoothAdapter  _bluetooth =
BluetoothAdapter.getDefaultAdapter();//获取暗中同意的蓝牙5.0适配器
    
//个中listenUsing揽胜极光fcommWithServiceRecord能够回来二个蓝牙5.0服务器蓝牙ServerSocker对象,个中参数PROTOCOL_SCHEME_猎豹CS陆FCOMM是二个String类型常量,代表蓝牙( Bluetooth® )服务器名称
    
//UUID.fromString(“a60f3五f0-b九三a-1一de-八a3九-0800200八c666”)是该蓝牙( Bluetooth® )服务器唯壹标示UUID。在客户端连接那些服务器时须要利用该UUID.
     private BluetoothServerSocker _serverSocket =
_bluetooth.listenUsingRfcommWithServiceRecord(PROTOCOL_SCHEME_RFCOMM,UUID.fromString(“a60f35f0-b93a-11de-8a39-08002009c666”));
   
   
连接之后方可经过蓝牙ServerSocket的accept方法来接过客户端请求,并作出相应处理代码如下:
     BluetoothSocket socket =
_serverSocket.accept();//接收客户端的接二连三请求,accept方法重临叁个蓝牙( Bluetooth® )Socket对象表示客户端
     if(socket != null){//处理请求内容
     }
     …
     _serverSocket.close;//通过蓝牙5.0ServerSocker的close方法
关闭蓝牙伍.0服务器

   public class ServerSocketActivity extends
ListActivity{//蓝牙Socket服务器
    /* 一些常量,代表服务器的名称 */
    public static final String PROTOCOL_SCHEME_L2CAP = “btl2cap”;
    public static final String PROTOCOL_SCHEME_RFCOMM = “btspp”;
    public static final String PROTOCOL_SCHEME_BT_OBEX = “btgoep”;
    public static final String PROTOCOL_SCHEME_TCP_OBEX =
“tcpobex”;
    private static final String TAG =
ServerSocketActivity.class.getSimpleName();
    private Handler _handler = new Handler();
    private BluetoothAdapter _bluetooth =
蓝牙伍.0( Bluetooth® )Adapter.getDefaultAdapter();// 取得默许的Bluetooth适配器
    private BluetoothServerSocket _serverSocket;//蓝牙( Bluetooth® )服务器
    private Thread _serverWorker = new Thread() {//
线程-监听客户端的链接
     public void run() {
      listen();
     };
    };
    protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
    
getWindow().setFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND,WindowManager.LayoutParams.FLAG_BLUR_BEHIND);
     setContentView(R.layout.server_socket);
     if (!_bluetooth.isEnabled()) {
      finish();
      return;
     }
     _serverWorker.start();//开首监听 开启线程
    }
    protected void onDestroy() {
     super.onDestroy();
     shutdownServer();
    }
    protected void finalize() throws Throwable {
     super.finalize();
     shutdownServer();
    }
    private void shutdownServer() {//结束服务器
     new Thread() {
      public void run() {
       _serverWorker.interrupt();
       if (_serverSocket != null) {
        try {
         _serverSocket.close();//关闭服务器
        } catch (IOException e) {
         Log.e(TAG, “”, e);
        }
        _serverSocket = null;
       }
      };
     }.start();
    }
    public void onButtonClicked(View view) {
     shutdownServer();
    }
    protected void listen() {
     try {
      // 创造四个蓝牙( Bluetooth® )服务器 参数分别:服务器名称、UUID
      _serverSocket =
_bluetooth.listenUsingRfcommWithServiceRecord(PROTOCOL_SCHEME_RFCOMM,
                   
UUID.fromString(“a60f35f0-b93a-11de-8a39-08002009c666”));
      final List<String> lines = new
ArrayList<String>();//客户端连线列表
将延续进的具有客户端都放进1个List中
      _handler.post(new Runnable() {
       public void run() {
        lines.add(“Rfcomm server started…”);
        ArrayAdapter<String> adapter = new
ArrayAdapter<String>(ServerSocketActivity.this,android.R.layout.simple_list_item_1,
lines);
        setListAdapter(adapter);
       }
      });
      BluetoothSocket socket =
_serverSocket.accept();//接受客户端的总是请求
      if (socket != null) {//处理请求内容
       InputStream inputStream = socket.getInputStream();
       int read = -1;
       final byte[] bytes = new byte[2048];
       for (; (read = inputStream.read(bytes)) > -1;) {
        final int count = read;
        _handler.post(new Runnable(){
         public void run() {
          StringBuilder b = new StringBuilder();
           for (int i = 0; i < count; ++i) {
            if (i > 0) {
             b.append(‘ ‘);
            }
            String s = Integer.toHexString(bytes[i] & 0xFF);
            if (s.length() < 2) {
             b.append(‘0’);
            }
            b.append(s);
           }
          String s = b.toString();
          lines.add(s);
          ArrayAdapter<String> adapter = new
ArrayAdapter<String>(ServerSocketActivity.this,android.R.layout.simple_list_item_1,
lines);
          setListAdapter(adapter);
         }
        });
       }
      }
     } catch (IOException e) {
      Log.e(TAG, “”, e);
     } finally {
     }
    }
   }
   蓝牙伍.0客户端连接

   public class ClientSocketActivity  extends Activity{//Bluetooth客户端
    private static final String TAG =
ClientSocketActivity.class.getSimpleName();
    private static final int REQUEST_DISCOVERY = 0x1;;
    private Handler _handler = new Handler();
    private BluetoothAdapter _bluetooth =
BluetoothAdapter.getDefaultAdapter();
    protected void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
    
getWindow().setFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND,WindowManager.LayoutParams.FLAG_BLUR_BEHIND);
     setContentView(R.layout.client_socket);
     if (!_bluetooth.isEnabled()) {
      finish();
      return;
     }
     Intent intent = new Intent(this, DiscoveryActivity.class);
     Toast.makeText(this, “select device to connect”,
Toast.LENGTH_SHOWranglerT).show();//提醒选取三个要一而再的服务器(即搜索处理的蓝牙五.0设备)
     startActivityForResult(intent, REQUEST_DISCOVE奥迪Q三Y);//
跳转到搜索的Bluetooth设备列表区,进行分选
    }
    protected void onActivityResult(int requestCode, int resultCode,
Intent data) {//选择了服务器之后展开延续
     if (requestCode != REQUEST_DISCOVERY) {
      return;
     }
     if (resultCode != RESULT_OK) {
      return;
     }
     final BluetoothDevice device =
data.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);//因首先判断本地Bluetooth是不是运营,在连年时首先要力保本地连接已经运转
                   然后通过BluetoothDevice device =
Intent.getParcelableExtra(蓝牙5.0( Bluetooth® )Device.EXTRA_DEVICE);代码
                   取得要一而再的Bluetooth设备。
     new Thread() {
      public void run() {
       connect(device);//连接
      };
     }.start();
    }
    protected void connect(BluetoothDevice device) {
     BluetoothSocket socket = null;
     try {
      //创造叁个Socket连接:只需求服务器在登记时的UUID号
      // socket =
device.createRfcommSocketToServiceRecord(BluetoothProtocols.OBEX_OBJECT_PUSH_PROTOCOL_UUID);
      socket =
device.createRfcommSocketToServiceRecord(UUID.fromString(“a60f35f0-b93a-11de-8a39-08002009c666”));  
      socket.connect();//与服务器实行连接
     } catch (IOException e) {
      Log.e(TAG, “”, e);
     } finally {
      if (socket != null) {
       try {
        socket.close();
       } catch (IOException e) {
        Log.e(TAG, “”, e);
       }
      }
     }
    }
   }
   其余多少个类以供参考
   public class Activity01 extends Activity{
    /* 取得暗中认可的蓝牙5.0适配器 */
    private BluetoothAdapter _bluetooth    =
BluetoothAdapter.getDefaultAdapter();
    /* 请求打开蓝牙5.0 */
    private static final int REQUEST_ENABLE   = 0x1;
    /* 请求能够被搜索 */
    private static final int REQUEST_DISCOVERABLE = 0x2;
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
    }
    /* 开启蓝牙五.0 */
    public void onEnableButtonClicked(View view){
     // 用户请求打开Bluetooth
     //Intent enabler = new
Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
     //startActivityForResult(enabler, REQUEST_ENABLE);
     //打开Bluetooth
     _bluetooth.enable();
    }
    /* 关闭Bluetooth */
    public void onDisableButtonClicked(View view){
     _bluetooth.disable();
    }
    /* 使设备能够被搜索 */
    public void onMakeDiscoverableButtonClicked(View view){
     Intent enabler = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
     startActivityForResult(enabler, REQUEST_DISCOVERABLE);
    }
    /* 早先搜索 */
    public void onStartDiscoveryButtonClicked(View view){
     Intent enabler = new Intent(this, DiscoveryActivity.class);
     startActivity(enabler);
    }
    /* 客户端 */
    public void onOpenClientSocketButtonClicked(View view){
     Intent enabler = new Intent(this, ClientSocketActivity.class);
     startActivity(enabler);
    }
    /* 服务端 */
    public void onOpenServerSocketButtonClicked(View view){
     Intent enabler = new Intent(this, ServerSocketActivity.class);
     startActivity(enabler);
    }
    /* OBEX服务器 */
    public void onOpenOBEXServerSocketButtonClicked(View view){
     Intent enabler = new Intent(this, OBEXActivity.class);
     startActivity(enabler);
    }
   }

   public class OBEXActivity extends Activity{
    private static final String  TAG      = “@MainActivity”;
    private Handler     _handler    = new Handler();
    private BluetoothServerSocket _server;
    private BluetoothSocket   _socket;
    private static final int  OBEX_CONNECT   = 0x80;
    private static final int  OBEX_DISCONNECT   = 0x81;
    private static final int  OBEX_PUT    = 0x02;
    private static final int  OBEX_PUT_END   = 0x82;
    private static final int  OBEX_RESPONSE_OK  = 0xa0;
    private static final int  OBEX_RESPONSE_CONTINUE = 0x90;
    private static final int  BIT_MASK    = 0x000000ff;
    Thread t = new Thread() {
     public void run(){
      try{             
       _server =
BluetoothAdapter.getDefaultAdapter().listenUsingRfcommWithServiceRecord(“OBEX”,
null);             
       new Thread() {             
        public void run(){                  
         Log.d(“@Rfcom”, “begin close”);            
         try{           
          _socket.close();            
         }catch (IOException e){             
          Log.e(TAG, “”, e);            
         }          
         Log.d(“@Rfcom”, “end close”);            
        };           
       }.start();             
       _socket = _server.accept();             
       reader.start();              
       Log.d(TAG, “shutdown thread”);             
      }catch (IOException e){             
       e.printStackTrace();            
      }            
     };          
    };
    Thread reader = new Thread() {                         
     public void run(){             
      try{
       Log.d(TAG, “getting inputstream”);             
       InputStream inputStream =
_socket.getInputStream();             
       OutputStream outputStream =
_socket.getOutputStream();             
       Log.d(TAG, “got inputstream”);             
       int read = -1;           
       byte[] bytes = new byte[2048];
       ByteArrayOutputStream baos = new
ByteArrayOutputStream(bytes.length);
       while ((read = inputStream.read(bytes)) != -1){
        baos.write(bytes, 0, read);
        byte[] req = baos.toByteArray();
        int op = req[0] & BIT_MASK;
        Log.d(TAG, “read:” + Arrays.toString(req));
        Log.d(TAG, “op:” + Integer.toHexString(op));
        switch (op){
         case OBEX_CONNECT:
          outputStream.write(new byte[] { (byte) OBEX_RESPONSE_OK,
0, 7, 16, 0, 4, 0 });
          break;
         case OBEX_DISCONNECT:
          outputStream.write(new byte[] { (byte) OBEX_RESPONSE_OK,
0, 3, 0 });
          break;
         case OBEX_PUT:
          outputStream.write(new byte[] { (byte)
OBEX_RESPONSE_CONTINUE, 0, 3, 0 });
          break;
         case OBEX_PUT_END:
          outputStream.write(new byte[] { (byte) OBEX_RESPONSE_OK,
0, 3, 0 });
          break;
         default:
          outputStream.write(new byte[] { (byte) OBEX_RESPONSE_OK,
0, 3, 0 });
        }
        Log.d(TAG, new String(baos.toByteArray(), “utf-8”));
        baos = new ByteArrayOutputStream(bytes.length);
       }
       Log.d(TAG, new String(baos.toByteArray(), “utf-8”));
      }catch (IOException e){
       e.printStackTrace();
      }
     };
    };
    private Thread put = new Thread() {
     public void run(){            
     };           
    };
    public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     setContentView(R.layout.obex_server_socket);
     t.start();
    }
    protected void onActivityResult(int requestCode, int resultCode,
Intent data){
     Log.d(TAG, data.getData().toString());
     switch (requestCode){
      case (1):
       if (resultCode == Activity.RESULT_OK){
        Uri contactData = data.getData();
        Cursor c = managedQuery(contactData, null, null, null, null);
        for (; c.moveToNext();){
         Log.d(TAG, “c1—————————————“);
         dump(c);
         Uri uri = Uri.withAppendedPath(data.getData(),
ContactsContract.Contacts.Photo.CONTENT_DIRECTORY);
         Cursor c2 = managedQuery(uri, null, null, null, null);
         for (; c2.moveToNext();){
          Log.d(TAG, “c2—————————————“);
          dump(c2);
         }
        }
       }
       break;
     }
    }
    private void dump(Cursor c){
     for (int i = 0, size = c.getColumnCount(); i < size; ++i){
      String col = c.getColumnName(i);
      String s = c.getString(i);
      Log.d(TAG, col + “=” + s);
     }
    }
   }

   abstract class SamplesUtils{
    public static void indeterminate(Context context, Handler handler,
String message, final Runnable runnable, OnDismissListener
dismissListener){
     try{
      indeterminateInternal(context, handler, message, runnable,
dismissListener, true);
     }catch (Exception e){
      ; // nop.
     }
    }
    public static void indeterminate(Context context, Handler handler,
String message, final Runnable runnable, OnDismissListener
dismissListener,boolean cancelable){
     try{
      indeterminateInternal(context, handler, message, runnable,
dismissListener, cancelable);
     }catch (Exception e){
      ; // nop.
     }
    }
    private static ProgressDialog createProgressDialog(Context context,
String message){
     ProgressDialog dialog = new ProgressDialog(context);
     dialog.setIndeterminate(false);
     dialog.setMessage(message);
     return dialog;
    }
    private static void indeterminateInternal(Context context, final
Handler handler, String message, final Runnable runnable,
     OnDismissListener dismissListener, boolean cancelable){
      final ProgressDialog dialog = createProgressDialog(context,
message);
      dialog.setCancelable(cancelable);
      if (dismissListener != null){
       dialog.setOnDismissListener(dismissListener);
      }
      dialog.show();
      new Thread(){
       @Override
       public void run(){
        runnable.run();
        handler.post(new Runnable() {
         public void run(){
          try{
           dialog.dismiss();
          }catch (Exception e){
           ; // nop.
          }
         }
        });
       };
      }.start();
     }
   }

   discovery.xml
   <?xml version=”1.0″ encoding=”utf-8″?>
    <LinearLayout
     xmlns:android=”http://schemas.android.com/apk/res/android
     android:layout_width=”fill_parent”
     android:layout_height=”fill_parent”>
     <ListView
      android:id=”@+id/android:list”
      android:layout_width=”fill_parent”
      android:layout_height=”fill_parent” />
       <!–
       <TextView
        android:id=”@+id/android:empty”
        android:layout_width=”wrap_content”
        android:layout_height=”wrap_content”
        android:text=”no device found” />
       –>
    </LinearLayout>

   main.xml
   <?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”
     android:padding=”10dip”>
     <Button
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”打开Bluetooth”
      android:onClick=”onEnableButtonClicked” />
     <Button
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”关闭蓝牙伍.0″
      android:onClick=”onDisableButtonClicked” />
     <Button
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”允许搜索”
      android:onClick=”onMakeDiscoverableButtonClicked” />
     <Button
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”初阶搜寻”
      android:onClick=”onStartDiscoveryButtonClicked” />
     <Button
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”客户端”
      android:onClick=”onOpenClientSocketButtonClicked” />
     <Button
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”服务器端”
      android:onClick=”onOpenServerSocketButtonClicked” />
     <Button
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”OBEX服务器”
      android:onClick=”onOpenOBEXServerSocketButtonClicked” />
    </LinearLayout>

   server_socket.xml
   <?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”
     android:padding=”10dip”>
     <Button
      android:layout_width=”fill_parent”
      android:layout_height=”wrap_content”
      android:text=”Stop server”
      android:onClick=”onButtonClicked” />
     <ListView
      android:id=”@+id/android:list”
      android:layout_width=”fill_parent”
      android:layout_height=”fill_parent” />
    </LinearLayout>

   obex_server_socket.xml
   <?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”
     android:padding=”10dip”>
    </LinearLayout>

   client_socket.xml
   <?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”
     android:padding=”10dip”>
    </LinearLayout>

   AndroidManifest.xml
   <?xml version=”1.0″ encoding=”utf-8″?>
    <manifest
     xmlns:android=”http://schemas.android.com/apk/res/android
     package=”com.yarin.android.Examples_08_09″
     android:versionCode=”1″
     android:versionName=”1.0″>
    <application android:icon=”@drawable/icon”
android:label=”@string/app_name”>
    <activity
android:name=”.Activity01″android:label=”@string/app_name”>
     <intent-filter>
      <action android:name=”android.intent.action.MAIN” />
      <category android:name=”android.intent.category.LAUNCHER”
/>
     </intent-filter>
    </activity>
    <activity
android:name=”.DiscoveryActivity”android:theme=”@style/Theme.Transparent”>
     <intent-filter>
      <action android:name=”android.intent.action.MAIN” />
      <category android:name=”android.intent.category.DEFAULT”
/>
     </intent-filter>
    </activity>
    <activity
android:name=”.ClientSocketActivity”android:theme=”@style/Theme.Transparent”>
     <intent-filter>
      <action android:name=”android.intent.action.MAIN” />
      <category android:name=”android.intent.category.DEFAULT”
/>
     </intent-filter>
    </activity>
    <activity
android:name=”.ServerSocketActivity”android:theme=”@style/Theme.Transparent”>
     <intent-filter>
      <action android:name=”android.intent.action.MAIN” />
      <category android:name=”android.intent.category.DEFAULT”
/>
     </intent-filter>
    </activity>
    <activity
android:name=”.OBEXActivity”android:theme=”@style/Theme.Transparent”>
     <intent-filter>
      <action android:name=”android.intent.action.MAIN” />
      <category android:name=”android.intent.category.DEFAULT”
/>
     </intent-filter>
    </activity>
   </application>
    <uses-sdk android:minSdkVersion=”5″ />
    <uses-permission android:name=”android.permission.BLUETOOTH”
/>
    <uses-permission
android:name=”android.permission.BLUETOOTH_ADMIN” />
    <uses-permission
android:name=”android.permission.READ_CONTACTS”/>
   </manifest>

 

 

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图