android 半弧进度条 android进度条对话框

首先在onCreateDialog方法里创建一个ProgressDialog,如下：

1.  //this表示该对话框是针对当前Activity的
2.  progressDialog = new ProgressDialog(this);
3.  //设置最大值为100
4.  progressDialog.setMax(100);
5.  //设置进度条风格STYLE_HORIZONTAL
6.  progressDialog.setProgressStyle(
7.                  ProgressDialog.STYLE_HORIZONTAL);
8.  progressDialog.setTitle("进度条对话框");

接下来就是进度条的进度更新，因为对话框对象一直被当前Dialog保存着，所以onCreateDialog在下次调用对话框时不会在被调，所以

进度条更新操作不能在onCreateDialog里面，而是在onPrepareDialog里面进行。

首先要将进度条置为0

1.  progressDialog.incrementProgressBy(-progressDialog.getProgress());

increamentProgressBy源码中是调用了ProgressBar的setProgress(mProgress + diff); mProgress是当前进度值，这里的diff就是-progressDialog.getProgress(),最后结果为0，所以也可以这么用，效果和调用incrementProgressBy一样的，如下：

1.  progressDialog.onStart();
2.  progressDialog.setProgress(0);

值得一提的是，不能直接只用setProgress(0)来设置，这样的话，第一次弹出对话框效果可以和上面的一样，但是之后再弹出对话框的进度一直都是100。为什么这里不能直接用setProgress(0),查看源码可以知道，

1.  if (mHasStarted) {
2.        mProgress.setProgress(value);
3.        onProgressChanged();
4.  } else {
5.        mProgressVal = value;
6.  }

mHasStarted第一次调用的时候是true，当进度条达到100%时会调用onStop方法(此方法为protected,无法直接调用)，将mHasStarted设置为false，也就是无法setProgress(value)了，只能通过onStart来将mHasStarted设置为true。

当点击“显示进度条对话框”按钮，这时候需要很耗时然后才显示对话框，而往往都会导致假死，如果超过5秒未响应将强制关闭，所以这里需要添加个多线程来做进一步处理。而进度条的增加效果是很快的，所以这这里需要让大家看到效果，得停几毫秒后再继续。

为了使主线程不受影响(处理当前Activity的线程)，在点击按钮且耗时操作完后需要发送消息给主线程，主线程再做相应处理。线程之间的消息传递和异步处理是通过Handler来做处理的，相关代码如下：

1.  new Thread() {
2.          public void run() {
3.                  for(int i=0; i<=100; i++) {
4.                          handler.sendEmptyMessage(INCREASE);
5.                          if(progressDialog.getProgress() >= 100) {
6.                                  break;
7.                          }
8.                          try {
9.                                  Thread.sleep(50);
10.                          } catch (InterruptedException e) {
11.                                  e.printStackTrace();
12.                          }
13.                  }
14.          }
15.  }.start();

Handler的处理如下：

1.  handler = new Handler() {
2.          @Override
3.          public void handleMessage(Message msg) {
4.                  switch(msg.what) {
5.                          case INCREASE:
6.                                  progressDialog.incrementProgressBy(1);
7.                                  if(progressDialog.getProgress() >= 100) {
8.                                  //        progressDialog.dismiss();
9.                                  }
10.                                  break;
11.                  }
12.                  super.handleMessage(msg);
13.          }
14.  };

解释就到这里，先看个效果图：

实现步骤：

第一步，一个按钮用来点击后弹出对话框的

res/layout/progress_dialog_layout.xml

1.  <?xml version="1.0" encoding="utf-8"?>
2.  <LinearLayout
3.    xmlns:android="http://schemas.android.com/apk/res/android"
4.    android:layout_width="fill_parent"
5.    android:layout_height="wrap_content">
6.    <Button android:id="@+id/button"
7.      android:text="显示进度条对话框"
8.            android:layout_width="fill_parent"
9.            android:layout_height="wrap_content"/>
10.  </LinearLayout>

第二步，

src/com/dialog/activity/ProgressDialogActivity.java

1.  package com.dialog.activity;
2.  
3.  import android.app.Activity;
4.  import android.app.Dialog;
5.  import android.app.ProgressDialog;
6.  import android.os.Bundle;
7.  import android.os.Handler;
8.  import android.os.Message;
9.  import android.view.View;
10.  import android.widget.Button;
11.  
12.  public class ProgressDialogActivity extends Activity {
13.          
14.          private final int PROGRESS_DIALOG = 1;
15.          
16.          private final int INCREASE = 0;
17.          
18.          private ProgressDialog progressDialog = null;
19.          
20.          private Handler handler = null;
21.          
22.      @Override
23.      public void onCreate(Bundle savedInstanceState) {
24.          super.onCreate(savedInstanceState);
25.          setContentView(R.layout.progress_dialog_layout);
26.          
27.          Button button = (Button) findViewById(R.id.button);
28.          View.OnClickListener listener = 
29.                  new View.OnClickListener() {
30.                                  
31.                                  @Override
32.                                  public void onClick(View view) {
33.                                          showDialog(PROGRESS_DIALOG);
34.                                  }
35.                          };
36.                  button.setOnClickListener(listener);
37.                  
38.                  handler = new Handler() {
39.                          @Override
40.                          public void handleMessage(Message msg) {
41.                                  switch(msg.what) {
42.                                          case INCREASE:
43.                                                  progressDialog.incrementProgressBy(1);
44.                                                  if(progressDialog.getProgress() >= 100) {
45.                                                  //        progressDialog.dismiss();
46.                                                  }
47.                                                  break;
48.                                  }
49.                                  super.handleMessage(msg);
50.                          }
51.                  };
52.      }
53.      
54.      @Override
55.      public Dialog onCreateDialog(int id) {
56.              switch(id) {
57.                      case PROGRESS_DIALOG:        
58.                                  //this表示该对话框是针对当前Activity的
59.                                  progressDialog = new ProgressDialog(this);
60.                                  //设置最大值为100
61.                                  progressDialog.setMax(100);
62.                                  //设置进度条风格STYLE_HORIZONTAL
63.                                  progressDialog.setProgressStyle(
64.                                                  ProgressDialog.STYLE_HORIZONTAL);
65.                                  progressDialog.setTitle("进度条对话框");
66.                              break;
67.              }
68.              return progressDialog;
69.      }
70.      
71.          @Override
72.      public void onPrepareDialog(int id, Dialog dialog) {
73.              
74.              switch(id) {
75.                      case PROGRESS_DIALOG:
76.                              //将进度条清0
77.                              progressDialog.incrementProgressBy(-progressDialog.getProgress());
78.                              new Thread() {
79.                                      public void run() {
80.                                              for(int i=0; i<=100; i++) {
81.                                                      handler.sendEmptyMessage(INCREASE);
82.                                                          if(progressDialog.getProgress() >= 100) {
83.                                                                  break;
84.                                                          }
85.                                                          try {
86.                                                                  Thread.sleep(50);
87.                                                          } catch (InterruptedException e) {
88.                                                                  e.printStackTrace();
89.                                                          }
90.                                              }
91.                                      }
92.                              }.start();
93.                              break;
94.              }
95.      }
96.  }