Android第三周－自定义控件、Fragment、Hadler、Service、BroadcastReceive、webview、widget

一、自定义控件

1.单位

dp、sp、px

2.Inflater怎么使用

inflate把xml文件解析为view对象

LayoutInflater layoutInflater = getLayoutInflater()LayoutInflater layoutInflater = (LayoutInflater)getSystemService(LAYOUT_INFLATER_SERVICE)LayoutInflater layoutInflater = LayoutInflater.from(xxxActivity.this)

3.Theme和Style

Theme针对窗体级别的共同元素，改变窗体样式
Style针对窗体元素级别的共同元素，改变指定控件或layout样式
在AndroidManifest或布局文件中中使用，在Style文件夹下保存

4.View解析

构造器
onMesure()定大小
onLayout()定位置
onDraw()绘制
invalidate()刷新
Paint类，各种画图方法

5.自定义控件的自定义属性

1.新建自定义控件类

package com.geekband.Test01;import android.content.Context;import android.content.res.TypedArray;import android.graphics.Canvas;import android.graphics.Color;import android.graphics.Paint;import android.graphics.Rect;import android.util.AttributeSet;import android.view.View;/** * Function: * 做一个圆形的红色按钮 * 中间有一个白色的数字 * 数字起始为20 * 每点击一次减少1 */public class TestRedButton extends View implements View.OnClickListener {    private Paint mPaint;    private Rect mRect;    private int mNumber = 0;    private int mBackgroundColor;    private int mTextSize;    public TestRedButton(Context context) {        this(context, null);    }    public TestRedButton(Context context, AttributeSet attrs) {        this(context, attrs, 0);    }    public TestRedButton(Context context, AttributeSet attrs, int defStyleAttr) {        super(context,attrs, defStyleAttr);        init(context,attrs);    }    /**     * init the view     */    private void init(Context context, AttributeSet attrs) {        mPaint = new Paint();        mRect = new Rect();        this.setOnClickListener(this);        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.TestRedButton);        mBackgroundColor = typedArray.getColor(R.styleable.TestRedButton_backgroundColor, Color.BLUE);        mTextSize = typedArray.getDimensionPixelSize(R.styleable.TestRedButton_textSize, 18);    }    @Override    protected void onDraw(Canvas canvas) {        super.onDraw(canvas);        // 做一个圆形的红色按钮        // 设置画布为红色        /**         * 画一个红色的圆         */        mPaint.setColor(mBackgroundColor);        canvas.drawCircle(getWidth() / 2, getHeight() / 2, getWidth() / 2, mPaint);        // 中间有一个白色的数字        mPaint.setColor(Color.WHITE);        mPaint.setTextSize(200);        /**         * mRect是这个数字四周的边距         */        String text = String.valueOf(mNumber);        mPaint.getTextBounds(text, 0, text.length(), mRect);        int textWidth = mRect.width();        int textHeight = mRect.height();        canvas.drawText(text, getWidth() / 2 - textWidth / 2, getHeight() / 2 + textHeight / 2, mPaint);    }    @Override    public void onClick(View v) {        // 每点击一次减少1        if (mNumber > 0) {            mNumber--;        } else {            mNumber = 20;        }        invalidate();  // 刷新界面    }}

2.创建Activity类

package com.geekband.Test01;import android.app.Activity;import android.os.Bundle;public class TestViewButtonActivity extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_draw_view_test);    }}

3.创建layout文件，使用自定义控件

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"              xmlns:app="http://schemas.android.com/apk/res-auto"              android:orientation="vertical"              android:layout_width="match_parent"              android:layout_height="match_parent">    <com.geekband.Test01.TestRedButton        android:layout_width="300dp"        android:layout_height="300dp"        app:backgroundColor="@color/splashBackgroundColor"        app:textSize="18dp"        /></LinearLayout>

4.新建一个attrs.xml

<?xml version="1.0" encoding="utf-8"?><resources>    <declare-styleable name="TestRedButton">        <attr name="backgroundColor" format="color"/>        <attr name="textColor" format="color"/>        <attr name="textSize"  format="dimension"/>    </declare-styleable></resources>

5.在控件类中读取attrs，初始化给自定义控件类

二、Fragment

1.什么是Fragment

你可以把Fragment当成Activity的一个界面的一个组成部分，甚至Activity的界面可以完全有不同的Fragment组成
Fragment拥有自己的生命周期和接收、处理用户的事件
可以动态的添加、替换和移除某个Fragment

2.生命周期

Fragment必须是依存与Activity而存在的，因此Activity的生命周期会直接影响到Fragment的生命周期。官网这张图很好的说明了两者生命周期的关系：

可以看到Fragment比Activity多了几个额外的生命周期回调方法：

onAttach(Activity)
当Fragment与Activity发生关联时调用。

onCreateView(LayoutInflater, ViewGroup,Bundle)
创建该Fragment的视图

onActivityCreated(Bundle)
当Activity的onCreate方法返回时调用

onDestoryView()
与onCreateView想对应，当该Fragment的视图被移除时调用

onDetach()
与onAttach相对应，当Fragment与Activity关联被取消时调用

注意：除了onCreateView，其他的所有方法如果你重写了，必须调用父类对于该方法的实现，

3.静态使用Fragment

这是使用Fragment最简单的一种方式，把Fragment当成普通的控件，直接写在Activity的布局文件中。步骤：
1.TitleFragment的布局文件:

<?xml version="1.0" encoding="utf-8"?>  <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"      android:layout_width="match_parent"      android:layout_height="45dp"      android:background="@drawable/title_bar" >      <ImageButton          android:id="@+id/id_title_left_btn"          android:layout_width="wrap_content"          android:layout_height="wrap_content"          android:layout_centerVertical="true"          android:layout_marginLeft="3dp"          android:background="@drawable/showleft_selector" />      <TextView          android:layout_width="fill_parent"          android:layout_height="fill_parent"          android:gravity="center"          android:text="我不是微信"          android:textColor="#fff"          android:textSize="20sp"          android:textStyle="bold" />  </RelativeLayout>  

2.TitleFragment

import android.app.Fragment;  import android.os.Bundle;  import android.view.LayoutInflater;  import android.view.View;  import android.view.View.OnClickListener;  import android.view.ViewGroup;  import android.widget.ImageButton;  import android.widget.Toast;  public class TitleFragment extends Fragment  {      private ImageButton mLeftMenu;      @Override      public View onCreateView(LayoutInflater inflater, ViewGroup container,              Bundle savedInstanceState)      {          View view = inflater.inflate(R.layout.fragment_title, container, false);          mLeftMenu = (ImageButton) view.findViewById(R.id.id_title_left_btn);          mLeftMenu.setOnClickListener(new OnClickListener()          {              @Override              public void onClick(View v)              {                  Toast.makeText(getActivity(),                          "i am an ImageButton in TitleFragment ! ",                          Toast.LENGTH_SHORT).show();              }          });          return view;      }  }  

3.ContentFragment的其布局文件：

<?xml version="1.0" encoding="utf-8"?>  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"      android:layout_width="match_parent"      android:layout_height="match_parent"      android:orientation="vertical" >      <TextView          android:layout_width="fill_parent"          android:layout_height="fill_parent"          android:gravity="center"          android:text="使用Fragment做主面板"          android:textSize="20sp"          android:textStyle="bold" />  </LinearLayout> 

4.ContentFragment

import android.app.Fragment;  import android.os.Bundle;  import android.view.LayoutInflater;  import android.view.View;  import android.view.ViewGroup;  public class ContentFragment extends Fragment  {      @Override      public View onCreateView(LayoutInflater inflater, ViewGroup container,              Bundle savedInstanceState)      {          return inflater.inflate(R.layout.fragment_content, container, false);      }  }  

5.MainActivity

import android.app.Activity;  import android.os.Bundle;  import android.view.Window;  public class MainActivity extends Activity  {      @Override      protected void onCreate(Bundle savedInstanceState)      {          super.onCreate(savedInstanceState);          requestWindowFeature(Window.FEATURE_NO_TITLE);          setContentView(R.layout.activity_main);      }  }  

6.Activity的布局文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"      xmlns:tools="http://schemas.android.com/tools"      android:layout_width="match_parent"      android:layout_height="match_parent" >      <fragment          android:id="@+id/id_fragment_title"          android:name="com.zhy.zhy_fragments.TitleFragment"          android:layout_width="fill_parent"          android:layout_height="45dp" />      <fragment          android:layout_below="@id/id_fragment_title"          android:id="@+id/id_fragment_content"          android:name="com.zhy.zhy_fragments.ContentFragment"          android:layout_width="fill_parent"          android:layout_height="fill_parent" />  </RelativeLayout>  

4.动态使用Fragment

为了动态使用Fragment，我们修改一下Actvity的布局文件，中间使用一个FrameLayout，下面添加四个按钮~嘿嘿不是微信的按钮- -！
1.activity布局文件

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"      xmlns:tools="http://schemas.android.com/tools"      android:layout_width="match_parent"      android:layout_height="match_parent" >      <fragment          android:id="@+id/id_fragment_title"          android:name="com.zhy.zhy_fragments.TitleFragment"          android:layout_width="fill_parent"          android:layout_height="45dp" />      <include          android:id="@+id/id_ly_bottombar"          android:layout_width="fill_parent"          android:layout_height="55dp"          android:layout_alignParentBottom="true"          layout="@layout/bottombar" />      <FrameLayout          android:id="@+id/id_content"          android:layout_width="fill_parent"          android:layout_height="fill_parent"          android:layout_above="@id/id_ly_bottombar"          android:layout_below="@id/id_fragment_title" />  </RelativeLayout>  

底部四个按钮的布局就不贴了
2.下面主Activity

import android.app.Activity;  import android.app.FragmentManager;  import android.app.FragmentTransaction;  import android.os.Bundle;  import android.view.View;  import android.view.View.OnClickListener;  import android.view.Window;  import android.widget.LinearLayout;  public class MainActivity extends Activity implements OnClickListener  {      private LinearLayout mTabWeixin;      private LinearLayout mTabFriend;      private ContentFragment mWeixin;      private FriendFragment mFriend;      @Override      protected void onCreate(Bundle savedInstanceState)      {          super.onCreate(savedInstanceState);          requestWindowFeature(Window.FEATURE_NO_TITLE);          setContentView(R.layout.activity_main);          // 初始化控件和声明事件          mTabWeixin = (LinearLayout) findViewById(R.id.tab_bottom_weixin);          mTabFriend = (LinearLayout) findViewById(R.id.tab_bottom_friend);          mTabWeixin.setOnClickListener(this);          mTabFriend.setOnClickListener(this);          // 设置默认的Fragment          setDefaultFragment();      }      private void setDefaultFragment()      {          FragmentManager fm = getFragmentManager();          FragmentTransaction transaction = fm.beginTransaction();          mWeixin = new ContentFragment();          transaction.replace(R.id.id_content, mWeixin);          transaction.commit();      }      @Override      public void onClick(View v)      {          FragmentManager fm = getFragmentManager();          // 开启Fragment事务          FragmentTransaction transaction = fm.beginTransaction();          switch (v.getId())          {          case R.id.tab_bottom_weixin:              if (mWeixin == null)              {                  mWeixin = new ContentFragment();              }              // 使用当前Fragment的布局替代id_content的控件              transaction.replace(R.id.id_content, mWeixin);              break;          case R.id.tab_bottom_friend:              if (mFriend == null)              {                  mFriend = new FriendFragment();              }              transaction.replace(R.id.id_content, mFriend);              break;          }          // transaction.addToBackStack();          // 事务提交          transaction.commit();      }  }  

可以看到我们使用FragmentManager对Fragment进行了动态的加载，这里使用的是replace方法~~下一节我会详细介绍FragmentManager的常用API。
注：如果使用Android3.0以下的版本，需要引入v4的包，然后Activity继承FragmentActivity，然后通过getSupportFragmentManager获得FragmentManager。不过还是建议版Menifest文件的uses-sdk的minSdkVersion和targetSdkVersion都改为11以上，这样就不必引入v4包了。
代码中间还有两个Fragment的子类，ContentFragment上面已经见过，FriendFragment其实类似：

package com.zhy.zhy_fragments;  import android.app.Fragment;  import android.os.Bundle;  import android.view.LayoutInflater;  import android.view.View;  import android.view.ViewGroup;  public class FriendFragment extends Fragment  {      @Override      public View onCreateView(LayoutInflater inflater, ViewGroup container,              Bundle savedInstanceState)      {          return inflater.inflate(R.layout.fragment_friend, container, false);      }  }  

5.Fragment家族常用的API

Fragment常用的三个类：
android.app.Fragment 主要用于定义Fragment
android.app.FragmentManager 主要用于在Activity中操作Fragment
android.app.FragmentTransaction 保证一些列Fragment操作的原子性，熟悉事务这个词，一定能明白~
1. 获取FragmentManage的方式：
getFragmentManager() // v4中，getSupportFragmentManager
2. 主要的操作都是FragmentTransaction的方法
FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务
transaction.add()
往Activity中添加一个Fragment
transaction.remove()
从Activity中移除一个Fragment，如果被移除的Fragment没有添加到回退栈（回退栈后面会详细说），这个Fragment实例将会被销毁。
transaction.replace()
使用另一个Fragment替换当前的，实际上就是remove()然后add()的合体~
transaction.hide()
隐藏当前的Fragment，仅仅是设为不可见，并不会销毁
transaction.show()
显示之前隐藏的Fragment
detach()
会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。
attach()
重建view视图，附加到UI上并显示。
transatcion.commit()//提交一个事务
注意：常用Fragment的哥们，可能会经常遇到这样Activity状态不一致：State loss这样的错误。主要是因为：commit方法一定要在Activity.onSaveInstance()之前调用。
上述，基本是操作Fragment的所有的方式了，在一个事务开启到提交可以进行多个的添加、移除、替换等操作。findFragmentById方法

值得注意的是：如果你喜欢使用Fragment，一定要清楚这些方法，哪个会销毁视图，哪个会销毁实例，哪个仅仅只是隐藏，这样才能更好的使用它们。
a、比如：我在FragmentA中的EditText填了一些数据，当切换到FragmentB时，如果希望会到A还能看到数据，则适合你的就是hide和show；也就是说，希望保留用户操作的面板，你可以使用hide和show，当然了不要使劲在那new实例，进行下非null判断。
b、再比如：我不希望保留用户操作，你可以使用remove()，然后add()；或者使用replace()这个和remove,add是相同的效果。
c、remove和detach有一点细微的区别，在不考虑回退栈的情况下，remove会销毁整个Fragment实例，而detach则只是销毁其视图结构，实例并不会被销毁。那么二者怎么取舍使用呢？如果你的当前Activity一直存在，那么在不希望保留用户操作的时候，你可以优先使用detach。

三、Handler

1.handler定义

Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。
通常情况下，当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示”强制关闭”.
这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，但是当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的. 这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据), 把这些消息放入主线程队列中，配合主线程进行更新UI。

2.Handler一些特点

handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程), 也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。

3. Handler中分发消息的一些方法

post(Runnable)
postAtTime(Runnable,long)
postDelayed(Runnable long)
post类方法允许你排列一个Runnable对象到主线程队列中
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)
sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

4.实例

1)传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。

在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。

2)传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。

Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。
另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。

public class HandlerActivity extends Activity {             //声明两个按钮控件       private Button startButton = null;       private Button endButton = null;       @Override      public void onCreate(Bundle savedInstanceState) {           super.onCreate(savedInstanceState);           setContentView(R.layout.main);           //根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器           startButton = (Button)findViewById(R.id.startButton);           startButton.setOnClickListener(new StartButtonListener());           endButton = (Button)findViewById(R.id.endButton);           endButton.setOnClickListener(new EndButtonListener());       }       class StartButtonListener implements OnClickListener{           @Override          public void onClick(View v) {               //调用Handler的post方法，将要执行的线程对象添加到队列当中               handler.post(updateThread);           }       }       class EndButtonListener implements OnClickListener{           @Override          public void onClick(View v) {               handler.removeCallbacks(updateThread);           }       }       //创建一个Handler对象       Handler handler  = new Handler();       //将要执行的操作写在线程对象的run方法当中       Runnable updateThread =  new Runnable(){           @Override          public void run() {               System.out.println("UpdateThread");               //在run方法内部，执行postDelayed或者是post方法               handler.postDelayed(updateThread, 3000);           }       };   } 

程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。

3)Handler和多线程

post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。
这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。

public class HandlerTest2 extends Activity {      @Override     protected void onCreate(Bundle savedInstanceState) {          // TODO Auto-generated method stub      super.onCreate(savedInstanceState);      setContentView(R.layout.main);      //打印了当前线程的ID      System.out.println("Activity-->" + Thread.currentThread().getId());      //生成一个HandlerThread对象      HandlerThread handlerThread = new HandlerThread("handler_thread");      //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;      handlerThread.start();    //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。       // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程，可以处理消息循环；  其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是一一对应的。    MyHandler myHandler = new MyHandler(handlerThread.getLooper());      Message msg = myHandler.obtainMessage();      //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象      Bundle b = new Bundle();      b.putInt("age", 20);      b.putString("name", "Jhon");      msg.setData(b);      msg.sendToTarget();  //将msg发送到myHandler    }      //定义类    class MyHandler extends Handler{      public MyHandler(){      }      public MyHandler(Looper looper){          super(looper);      }      @Override     public void handleMessage(Message msg) {          Bundle b = msg.getData();          int age = b.getInt("age");          String name = b.getString("name");          System.out.println("age is " + age + ", name is" + name);          System.out.println("Handler--->" + Thread.currentThread().getId());          System.out.println("handlerMessage");          }      }  }  

这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。
这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。
另外再强调一遍，在UI线程（主线程）中：
mHandler=new Handler();
mHandler.post(new Runnable(){
void run(){
//执行代码..
}
});
这个线程其实是在UI线程之内运行的，并没有新建线程。

常见的新建线程的方法是：Thread thread = new Thread();thread.start();HandlerThread thread = new HandlerThread("string");thread.start();

实例2

首先来看OnCreate:    @Override    protected void onCreate(Bundle savedInstanceState)    {        super.onCreate(savedInstanceState);        setContentView(R.layout.queryresult);        tvResult = (TextView) findViewById(R.id.tvResult);        String queryString = getIntent().getStringExtra("query");        Log.d("threadId:", String.valueOf(Thread.currentThread().getId()));        // 声明一个handler，它的处理程序是实现了callback的类，这里我将这个activity继承了        // callback，所以可以传入this。        handler = new Handler(this);        // 新建一个线程（我们自己实现的线程），将上面的handler和查询的单词传入构造函数        GetHtmlThread thread = new GetHtmlThread(handler, getIntent()                .getStringExtra("query"));        // 开始线程        thread.start();        progressBar = (ProgressBar) findViewById(R.id.prb);        progressBar.setVisibility(View.VISIBLE);    }一些必要的注释我已经在代码注明了。代码中的那个GetHtmlThread线程是继承于Thread的一个类，然后自己实现里面的run方法，这个和c#里面不一样。感觉还是c#里面好理解一点。那我们就看看这个GetHtmlThread类：    public class GetHtmlThread extends Thread    {        private Handler handler; // 传入的handler        String queryKey; // 要查询的单词        public GetHtmlThread(Handler handler, String queryKey)        {            this.handler = handler;            this.queryKey = queryKey;        }        @Override        public void run() // 线程处理的内容        {            // 获得网页中关于这个词的解释，返回的网页内容            String a = GetTranslateHtml(queryKey);            // 定义一个消息，用于发给UI线程的handler处理            Message msg = new Message();            Bundle bundle = new Bundle();            // 将查询的结果放进msg中            bundle.putString("answer", a);            msg.setData(bundle);            // 设置这个msg的标识，这样UI中的handler才能根据这个更改对应的UI            msg.what = 0;            // 将消息发送给UI中的handler处理            handler.sendMessage(msg);            super.run();        }    }现在线程中的消息发送出去了。我们再到UI线程中处理这个消息。代码如下：    /**     * 继承了callback后，必须要实现这个方法。即上面那个handler的处理都在这里进行     */    @Override    public boolean handleMessage(Message msg)    {        // 通过判断msg.what来判断到底是哪个"事件"要进行处理        switch (msg.what)        {            case 0:                progressBar.setVisibility(View.GONE);                // 拿出msg中的数据并显示出来                Bundle bundle = msg.getData();                tvResult.setText(bundle.getString("answer"));                break;            default:                break;        }        return false;    }

四、Service

http://blog.csdn.net/pi9nc/article/details/18764415

五、BroadcastReceive

http://blog.csdn.net/wuyinlei/article/details/51029308

六、webview

http://liangruijun.blog.51cto.com/3061169/647456/

七、widget

挂件