自定义ProgressDialog进度条对话框用法详解

ProgressDialog的基本用法

本文转自:

ProgressDialog为进度对话框。android手机自带的对话框显得比较单一,我们可以通过ProgressDialog来自己定义对话框中将要显示出什么东西。

 

首先看看progressDialog里面的方法

摘要: 创建对话框 一个对话框一般是一个出现在当前Activity之上的一个小窗口.
处于下面的Activity失去焦点, 对话框接受所有的用户交互.
对话框一般用于提示信息和与当前应用程序直接相关的小功能.Android API
支持下列类型 …

setProgressStyle:设置进度条风格,风格为圆形,旋转的。

创建对话框   一个对话框一般是一个出现在当前Activity之上的一个小窗口.
处于下面的Activity失去焦点, 对话框接受所有的用户交互.
对话框一般用于提示信息和与当前应用程序直接相关的小功能.
  Android API 支持下列类型的对话框对象:
  警告对话框 AlertDialog:  一个可以有0到3个按钮,
一个单选框或复选框的列表的对话框. 警告对话框可以创建大多数的交互界面,
是推荐的类型.
  进度对话框 ProgressDialog:  显示一个进度环或者一个进度条.
由于它是AlertDialog的扩展, 所以它也支持按钮.
  日期选择对话框 DatePickerDialog:  让用户选择一个日期.
  时间选择对话框 TimePickerDialog:  让用户选择一个时间.
  如果你希望自定义你的对话框, 可以扩展Dialog类.
  Showing a Dialog 显示对话框
  一个对话框总是被创建和显示为一个Activity的一部分.
你应该在Activity的onCreateDialog(int)中创建对话框.
当你使用这个回调函数时,Android系统自动管理每个对话框的状态并将它们和Activity连接,
将Activity变为对话框的”所有者”. 这样,每个对话框从Activity继承一些属性.
例如,当一个对话框打开时, MENU键会显示Activity的菜单,
音量键会调整Activity当前使用的音频流的音量.
  注意: 如果你希望在onCreateDialog()方法之外创建对话框,
它将不会依附在Activity上.
你可以使用setOwnerActivity(Activity)来将它依附在Activity上.
  当你希望显示一个对话框时, 调用showDialog(int)并将对话框的id传给它.
  当一个对话框第一次被请求时,Android调用onCreateDialog(int).
这里是你初始化对话框的地方. 这个回调函数传入的id和showDialog(int)相同.
创建对话框之后,将返回被创建的对象.
  在对话框被显示之前,Android还会调用onPrepareDialog(int, Dialog).
如果你希望每次显示对话框时有动态更改的内容, 那么就改写这个函数.
该函数在每次一个对话框打开时都调用.
如果你不定义该函数,则对话框每次打开都是一样的.
该函数也会传入对话框的id以及你在onCreateDialog()中创建的Dialog对象.
  最好的定义onCreateDialog(int) 和onPrepareDialog(int, Dialog)
的方法就是使用一个switch语句来检查传入的id. 每个case创建相应的对话框.
例如, 一个游戏使用两个对话框: 一个来指示游戏暂停,另一个指示游戏结束.
首先, 为它们定义ID:static final int DIALOG_PAUSED_ID = 0;
static final int DIALOG_GAMEOVER_ID = 1; 
然后, 在onCreateDialog(int)中加入一个switch语句:

setTitlt:设置标题
setMessage:设置提示信息;
setIcon:设置标题图标;
setIndeterminate:设置ProgressDialog
的进度条是否不明确;这个属性对于ProgressDailog默认的转轮模式没有实际意义,默认下设置为true,它仅仅对带有ProgressBar的Dialog有作用。修改这个属性为false后可以实时更新进度条的进度。

view
plain

setCancelable:设置ProgressDialog 是否可以按返回键取消;
CancelListner:当前Dialog强制取消之后将会被执行,通常用来清理未完成的任务。

  1. protected Dialog onCreateDialog(int id) {  
  2.     Dialog dialog;  
  3.     switch(id) {  
  4.     case DIALOG_PAUSED_ID:  
  5.         // do the work to define the pause Dialog  
  6.         break;  
  7.     case DIALOG_GAMEOVER_ID:  
  8.         // do the work to define the game over Dialog  
  9.         break;  
  10.     default:  
  11.         dialog = null;  
  12.     }  
  13.     return dialog;  
  14. }   

setButton:设置ProgressDialog 的一个Button(需要监听Button事件);

  注意: 在这个例子中,
case语句为空因为定义Dialog的程序在后面会有介绍.
  在需要显示对话框是, 调用showDialog(int), 传入对话框的id:
  showDialog(DIALOG_PAUSED_ID);Dismissing a Dialog 解除对话框
  当你准备关闭对话框时, 你可以使用dismiss()函数. 如果需要的话,
你也可以从Activity调用dismissDialog(int), 二者效果是一样的.
  如果你使用onCreateDialog(int)来管理你的对话框的状态,
那么每次你的对话框被解除时, 该对话框对象的状态会被Activity保存.
如果你决定你不再需要这个对象或者需要清除对话框的状态, 那么你应该调用
removeDialog(int). 这将把所有该对象的内部引用移除,
如果该对话框在显示的话将被解除.
  Using dismiss listeners 使用解除监听器
  如果你希望在对话框解除时运行某些程序,
那么你应该给对话框附加一个解除监听器.
  首先定义DialogInterface.OnDismissListener接口. 这个接口只有一个方法,
onDismiss(DialogInterface), 该方法将在对话框解除时被调用.
  然后将你的OnDismissListener实现传给setOnDismissListener().
  然而,注意对话框也可以被”取消”. 这是一个特殊的情形,
它意味着对话框被用户显式的取消掉. 这将在用户按下”back”键时,
或者对话框显式的调用cancel()(按下对话框的cancel按钮)时发生.
当一个对话框被取消时, OnDismissListener将仍然被通知,
但如果你希望在对话框被显示取消(而不是正常解除)时被通知,
则你应该使用setOnCancelListener()注册一个DialogInterface.OnCancelListener.
  Creating an AlertDialog 创建警告对话框
  An AlertDialog is an extension of the Dialog class. It is capable of
constructing most dialog user interfaces and is the suggested dialog
type. You should use it for dialogs that use any of the following
features:
  一个警告对话框是对话框的一个扩展.
它能够创建大多数对话框用户界面并且是推荐的对话框类新星.
对于需要下列任何特性的对话框,你都应该使用它:
  一个标题
  一条文字消息
  1个-3个按钮
  一个可选择的列表(单选框或者复选框)
  要创建一个AlertDialog, 使用AlertDialog.Builder子类.
使用AlertDialog.Builder(Context)来得到一个Builder,
然后使用该类的公有方法来定义AlertDialog的属性. 设定好以后,
使用create()方法来获得AlertDialog对象.
  下面的主题展示了如何为AlertDialog定义不同的属性,
使用AlertDialog.Builder类. 如果你使用这些示例代码,
你可以在onCreateDialog()中返回最后的Dialog对象来获得图片中对话框的效果.
  Adding buttons 增加按钮

show:显示ProgressDialog。

图片 1

cancel:删除progressdialog

要创建一个如图所示的窗口, 使用set…Button()方法:

dismiss: 删除progressdialog 作用和cancel相同

view
plain

setProgress(intCounter);更新进度条,当然一般都需要Handler的结合来更新进度条
<!–EndFragment–>

  1. AlertDialog.Builder builder = new AlertDialog.Builder(this);  
  2. builder.setMessage(“Are you sure you want to exit?”)  
  3.        .setCancelable(false)  
  4.        .setPositiveButton(“Yes”, new DialogInterface.OnClickListener() {  
  5.            public void onClick(DialogInterface dialog, int id) {  
  6.                 MyActivity.this.finish();  
  7.            }  
  8.        })  
  9.        .setNegativeButton(“No”, new DialogInterface.OnClickListener() {  
  10.            public void onClick(DialogInterface dialog, int id) {  
  11.                 dialog.cancel();  
  12.            }  
  13.        });  
  14. AlertDialog alert = builder.create();  

然后我们看看效果

首先,使用setMessage(CharSequence)为对话框增加一条消息。 然后,
开始连续调用方法,
使用setCancelable(boolean)将对话框设为不可取消(不能使用back键来取消)。对每一个按钮,使用set…Button()方法,该方法接受按钮名称和一个DialogInterface.OnClickListener,该监听器定义了当用户选择该按钮时应做的动作。
  注意:对每种按钮类型,只能为AlertDialog创建一个。也就是说,一个AlertDialog不能有两个以上的”positive”按钮。这使得可能的按钮数量最多为三个:肯定、否定、中性。这些名字和实际功能没有联系,但是将帮助你记忆它们各做什么事情。

图片 2

Adding a list 增加列表

实现代码如下

图片 3

<span style=””>package cn.android;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;
public class SecondActivity extends Activity implements Runnable{
/**
* Called when the activity is first created.
* Activity入口
* */
private Button b_dialog,b_dialog1,button;//两个按钮
private ProgressDialog pd,pd1;//进度条对话框
private int count;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.second);//关联对应的界面
b_dialog = (Button)this.findViewById(R.id.button_dialog);
b_dialog1 = (Button)this.findViewById(R.id.Button_dialog1);
//处理事件发生时要做的事
b_dialog.setOnClickListener(listener);
b_dialog1.setOnClickListener(listener);
</span>
<span style=””> }
//定义监听器对象
private OnClickListener listener = new OnClickListener() {
// 鼠标按下后
public void onClick(View v) {
// 得到当前被触发的事件的ID —— 类型是int
int id = v.getId();
if(id == R.id.button_dialog){
//按下确定键就会消失的进程对话框
// pd = new ProgressDialog(SecondActivity.this);//
创建ProgressDialog对象
// pd.setProgressStyle(ProgressDialog.STYLE_SPINNER);//
设置进度条风格,风格为圆形,旋转的
// pd.setTitle(“提示”);// 设置ProgressDialog 标题
// pd.setMessage(“这是一个圆形进度条对话框”);//
设置ProgressDialog提示信息
// pd.setIcon(R.drawable.icon);// 设置ProgressDialog标题图标
// // 设置ProgressDialog 的进度条是否不明确 false 就是不设置为不明确
// pd.setIndeterminate(false);
// pd.setCancelable(true); // 设置ProgressDialog 是否可以按退回键取消
// pd.setButton(“确定”, new Bt1DialogListener()); // 设置ProgressDialog
的一个Button
// pd.show(); // 让ProgressDialog显示
//过1秒钟就会自己消失的进程对话框
//弹出另外一种对话框
pd = ProgressDialog.show(SecondActivity.this, “自动关闭对话框”,
“Working,,,,,,1秒”, true, false);
Thread thread = new Thread(SecondActivity.this);//开启一个线程来延时
thread.start();//启动线程
}else if(id == R.id.Button_dialog1){
pd1 = new ProgressDialog(SecondActivity.this);//
创建ProgressDialog对象
pd1.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);//
设置进度条风格,风格为圆形,旋转的
pd1.setTitle(“提示”);// 设置ProgressDialog 标题
pd1.setMessage(“这是一个条状进度条对话框”);//
设置ProgressDialog提示信息
pd1.setIcon(R.drawable.secondback);// 设置ProgressDialog标题图标
// 设置ProgressDialog 的进度条是否不明确 false 就是不设置为不明确
pd1.setIndeterminate(false);
pd1.setCancelable(true); // 设置ProgressDialog 是否可以按退回键取消
pd1.setProgress(100);// 设置ProgressDialog 进度条进度
pd1.show(); // 让ProgressDialog显示
count = 0;
new Thread() {
public void run() {
try {
while(count <= 100) {
// 由线程来控制进度
pd1.setProgress(count++);
Thread.sleep(100);
}
pd1.cancel();
} catch (Exception e) {
pd1.cancel();
}
}
}.start();
}
}
};
//run的是实现
public void run() {
try {
Thread.sleep(1000);//睡1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
handler.sendEmptyMessage(0);//传送消息
}
//定义处理消息的对象
private Handler handler = new Handler(){
//加入传消息来了就这么么办
public void handleMessage(Message msg){
pd.dismiss();//对话框消失
Toast.makeText(SecondActivity.this, “对话框就消失了”, 3).show();
}
};
// pdButton01的监听器类
class Bt1DialogListener implements DialogInterface.OnClickListener {
@Override
public void onClick(DialogInterface dialog, int which) {
// 点击“确定”按钮取消对话框
dialog.cancel();
}
}
}
</span>

要创建一个具有可选项的AlertDialog,使用setItems()方法:

您可能感兴趣的文章:

  • Android中自定义对话框(Dialog)的实例代码
  • Android实现点击AlertDialog上按钮时不关闭对话框的方法
  • Android实现底部对话框BottomDialog弹出实例代码
  • 实例详解Android自定义ProgressDialog进度条对话框的实现
  • Android中AlertDialog各种对话框的用法实例详解
  • android
    对话框弹出位置和透明度的设置具体实现方法
  • Android仿QQ消息提示实现弹出式对话框
  • Android使用setCustomTitle()方法自定义对话框标题
  • Android
    UI设计系列之自定义Dialog实现各种风格的对话框效果(7)
  • kotlin使用建造者模式自定义对话框

view
plain

  1. final CharSequence[] items = {“Red”, “Green”, “Blue”};   
  2. AlertDialog.Builder builder = new AlertDialog.Builder(this);  
  3. builder.setTitle(“Pick a color”);  
  4. builder.setItems(items, new DialogInterface.OnClickListener() {  
  5.     public void onClick(DialogInterface dialog, int item) {  
  6.         Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show();  
  7.     }  
  8. });  
  9. AlertDialog alert = builder.create();  

首先增加一个标题。然后使用setItems()增加一个可选列表,该列表接受一个选项名称的列表和一个DialogInterface.OnClickListener,
后者定义了选项对应的响应。

Adding checkboxes and radio buttons 增加单选框和复选框

 图片 4

要创建一个带有多选列表或者单选列表的对话框,
使用setMultiChoiceItems()和setSingleChoiceItems()方法。如果你在onCreateDialog()中创建可选择列表,
Android会自动管理列表的状态. 只要activity仍然活跃,
那么对话框就会记住刚才选中的选项,但当用户退出activity时,该选择丢失。
  注意: 要在你的acitivity离开和暂停时保存选择,
你必须在activity的声明周期中正确的保存和恢复设置。为了永久性保存选择,你必须使用数据存储技术中的一种。
  要创建一个具有单选列表的AlertDialog,只需将一个例子中的setItems()换成
setSingleChoiceItems():

view
plain

  1. final CharSequence[] items = {“Red”, “Green”, “Blue”};   
  2. AlertDialog.Builder builder = new AlertDialog.Builder(this);  
  3. builder.setTitle(“Pick a color”);  
  4. builder.setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {  
  5.     public void onClick(DialogInterface dialog, int item) {  
  6.         Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show();  
  7.     }  
  8. });  
  9. AlertDialog alert = builder.create();  

第二个参数是默认被选中的选项位置,使用“-1”来表示默认情况下不选中任何选项。

Creating a ProgressDialog 创建进度对话框

图片 5

一个ProgressDialog(进度对话框)是AlertDialog的扩展。它可以显示一个进度的动画――进度环或者进度条。这个对话框也可以提供按钮,例如取消一个下载等。
  打开一个进度对话框很简单,只需要调用
ProgressDialog.show()即可。例如,上图的对话框可以不通过onCreateDialog(int),而直接显示:
  ProgressDialog dialog = ProgressDialog.show(MyActivity.this, “”,
  ”Loading. Please wait…”, true);
  第一个参数是应用程序上下文。第二个为对话框的标题(这里为空),第三个为对话框内容,
最后一个为该进度是否为不可确定的(这只跟进度条的创建有关,见下一节)。
  进度对话框的默认样式为一个旋转的环。如果你希望显示进度值,请看下一节。
  Showing a progress bar 显示进度条
  使用一个动画进度条来显示进度:
  使用
ProgressDialog(Context)构造函数来初始化一个ProgressDialog对象。
  将进度样式设置为”STYLE_HORIZONTAL”,使用setProgressStyle(int)方法。并且设置其它属性,例如内容等。
  在需要显示时调用show()或者从onCreateDialog(int)回调函数中返回该ProgressDialog。
  你可以使用
setProgress(int)或者incrementProgressBy(int)来增加显示的进度。
  例如,你的设置可能像这样:ProgressDialog progressDialog;
progressDialog = new ProgressDialog(mContext);
progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
progressDialog.setMessage(“Loading…”);
progressDialog.setCancelable(false);
  设置很简单。大部分创建进度对话框需要的代码是在更新它的进程中。你可能需要在一个新的线程中更新它,并使用Handler来将进度报告给Activity。如果你不熟悉使用Handler和另外的线程,请看下列例子,该例子使用了一个新的线程来更新进度。
  Example ProgressDialog with a second thread
例–使用一个线程来显示进度对话框
  这个例子使用一个线程来跟踪一个进程的进度(其实为从1数到100)。每当进度更新时,该线程通过Handler给主activity发送一个消息。主Activity更新ProgressDialog.package
com.example.progressdialog;

view
plain

  1. import android.app.Activity;  
  2. import android.app.Dialog;  
  3. import android.app.ProgressDialog;  
  4. import android.os.Bundle;  
  5. import android.os.Handler;  
  6. import android.os.Message;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Button;  
  10. public class NotificationTest extends Activity {  
  11.     static final int PROGRESS_DIALOG = 0;  
  12.     Button button;  
  13.     ProgressThread progressThread;  
  14.     ProgressDialog progressDialog;  
  15.     /** Called when the activity is first created. */  
  16.     public void onCreate(Bundle savedInstanceState) {  
  17.         super.onCreate(savedInstanceState);  
  18.         setContentView(R.layout.main);   
  19.         // Setup the button that starts the progress dialog  
  20.         button = (Button) findViewById(R.id.progressDialog);  
  21.         button.setOnClickListener(new OnClickListener(){  
  22.             public void onClick(View v) {  
  23.                 showDialog(PROGRESS_DIALOG);  
  24.             }  
  25.         });  
  26.     }  
  27.     protected Dialog onCreateDialog(int id) {  
  28.         switch(id) {  
  29.         case PROGRESS_DIALOG:  
  30.             progressDialog = new ProgressDialog(NotificationTest.this);  
  31.             progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);  
  32.             progressDialog.setMessage(“Loading…”);  
  33.             progressThread = new ProgressThread(handler);  
  34.             progressThread.start();  
  35.             return progressDialog;  
  36.         default:  
  37.             return null;  
  38.         }  
  39.     }   
  40.     // Define the Handler that receives messages from the thread and update the progress  
  41.     final Handler handler = new Handler() {  
  42.         public void handleMessage(Message msg) {  
  43.             int total = msg.getData().getInt(“total”);  
  44.             progressDialog.setProgress(total);  
  45.             if (total >= 100){  
  46.                 dismissDialog(PROGRESS_DIALOG);  
  47.                 progressThread.setState(ProgressThread.STATE_DONE);  
  48.             }  
  49.         }  
  50.     };   
  51.     /** Nested class that performs progress calculations (counting) */  
  52.     private class ProgressThread extends Thread {  
  53.         Handler mHandler;  
  54.         final static int STATE_DONE = 0;  
  55.         final static int STATE_RUNNING = 1;  
  56.         int mState;  
  57.         int total;  
  58.         ProgressThread(Handler h) {  
  59.             mHandler = h;  
  60.         }  
  61.         public void run() {  
  62.             mState = STATE_RUNNING;     
  63.             total = 0;  
  64.             while (mState == STATE_RUNNING) {  
  65.                 try {  
  66.                     Thread.sleep(100);  
  67.                 } catch (InterruptedException e) {  
  68.                     Log.e(“ERROR”, “Thread Interrupted”);  
  69.                 }  
  70.                 Message msg = mHandler.obtainMessage();  
  71.                 Bundle b = new Bundle();  
  72.                 b.putInt(“total”, total);  
  73.                 msg.setData(b);  
  74.                 mHandler.sendMessage(msg);  
  75.                 total++;  
  76.             }  
  77.         }  
  78.         /* sets the current state for the thread, 
  79.          * used to stop the thread */  
  80.         public void setState(int state) {  
  81.             mState = state;  
  82.         }  
  83.     }  
  84. }  

Creating a Custom Dialog 创建自定义对话框

图片 6

如果你想自定义一个对话框,你可以使用布局元素来创造你的对话框的布局。定义好布局后,将根View对象或者布局资源ID传给setContentView(View).
例如,创建如图所示的对话框:
创建一个xml布局custom_dialog.xml:

view
plain

  1. ”  
  2.               android:id=”@+id/layout_root”  
  3.               android:orientation=”horizontal”  
  4.               android:layout_width=”fill_parent”  
  5.               android:layout_height=”fill_parent”  
  6.               android:padding=”10dp”  
  7.               >  
  8.                    android:layout_width=”wrap_content”  
  9.                android:layout_height=”fill_parent”  
  10.                android:layout_marginRight=”10dp”  
  11.                />  
  12.                   android:layout_width=”wrap_content”  
  13.               android:layout_height=”fill_parent”  
  14.               android:textColor=”#FFF”  
  15.               />  

该xml定义了一个LinearLayout中的一个ImageView 和一个TextView。
将以上布局设为对话框的content view,并且定义ImageView 和
TextView的内容:

view
plain

  1. Context mContext = getApplicationContext();  
  2. Dialog dialog = new Dialog(mContext);   
  3. dialog.setContentView(R.layout.custom_dialog);  
  4. dialog.setTitle(“Custom Dialog”);  
  5. TextView text = (TextView) dialog.findViewById(R.id.text);  
  6. text.setText(“Hello, this is a custom dialog!”);  
  7. ImageView image = (ImageView) dialog.findViewById(R.id.image);  
  8. image.setImageResource(R.drawable.android);  

在初始化Dialog之后,使用setContentView(int),将布局资源id传给它。现在Dialog有一个定义好的布局,你可以使用findViewById(int)来找到该元素的id并修改它的内容。
  使用前面所讲的方法显示对话框。
  一个使用Dialog类建立的对话框必须有一个标题。如果你不调用setTitle(),那么标题区域会保留空白。如果你不希望有一个标题,那么你应该使用AlertDialog类来创建自定义对话框。然而,由于一个AlertDialog使用AlertDialog.Builder类来建立最方便,所以你没有方法使用setContentView(int),而是只能使用setView(View)。该方法接受一个View对象,所以你需要从xml中展开你的根View。
  要展开一个xml布局,使用 getLayoutInflater() (或
getSystemService())取得LayoutInflater,然后调用inflate(int,
ViewGroup),第一个参数为布局id,而第二个参数为根view的id。现在,你可以使用展开后的布局来找到View对象并定义ImageView和TextView元素的内容。然后实例化AlertDialog.Builder并使用setView(View)来为对话框设置展开后的布局。例如:

view
plain

  1. AlertDialog.Builder builder;  
  2. AlertDialog alertDialog;   
  3. Context mContext = getApplicationContext();  
  4. LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(LAYOUT_INFLATER_SERVICE);  
  5. View layout = inflater.inflate(R.layout.custom_dialog,  
  6.                                (ViewGroup) findViewById(R.id.layout_root));  
  7. TextView text = (TextView) layout.findViewById(R.id.text);  
  8. text.setText(“Hello, this is a custom dialog!”);  
  9. ImageView image = (ImageView) layout.findViewById(R.id.image);  
  10. image.setImageResource(R.drawable.android);  
  11. builder = new AlertDialog.Builder(mContext);  
  12. builder.setView(layout);  
  13. alertDialog = builder.create();  

使用AlertDialog来自定义对话框,可以利用其内置特性例如按钮、选择列表、标题、图标等。

显示对话框

    对话框经常作为Activity的一部分来创建和显示。你通常应该从protected
Dialog Activity.onCreateDialog (int
id) 
回调方法里创建对话框。当你使用这个回调函数时,Android系统会有效的设置这个Activity为每个对话框的所有者,从而自动管理每个对话框的状态并挂靠到Activity上。这样,每个对话框继承这个Activity的特定属性。比如,当一个对话框打开时,菜单键显示为这个Activity定义的选项菜单,音量键修改Activity使用的音频流。

  1. 注意: 如果你决定在onCreateDialog()方法之外创建一个对话框,它将不会被附着到活动上。不过,你可以通过setOwnerActivity(Activity)把它附着到一个活动上。 

    当你想要显示一个对话框时,调用showDialog(int
id) 方法并传递一个唯一标识这个对话框的整数。

  
 当对话框第一次被请求时,Android从你的Activity中调用onCreateDialog(int
id),你应该在这里初始化这个对话框Dialog。这个回调方法被传以和showDialog(int
id)相同的ID。当你创建这个对话框后,在Activity的最后返回这个对象。

    在对话框被显示之前,Android还调用了可选的回调函数onPrepareDialog(int
id, Dialog).
如果你想在每一次对话框被打开时改变它的任何属性,你可以定义这个方法。这个方法在每次打开对话框时被调用,而onCreateDialog(int)
仅在对话框第一次打开时被调用
。如果你不定义onPrepareDialog(),那么这个对话框将保持和上次打开时一样。这个方法也被传递以对话框的ID,和在onCreateDialog()中创建的对话框对象。(个人理解是,在本Activity里第一次show某个Dialog,则先调用onCreateDialog,得到返回的Dialog对象并挂靠在Activity,保存Dialog对象的引用,然后才显示Dialog。这样子,下次再show
Dialog就不用重新创建Dialog对象,而是重用旧的)

    定义onCreateDialog(int) 和 onPrepareDialog(int,
Dialog)
 回调函数的最佳方法是使用一个switch 语句来检查传递进来的id
参数。每个case
应该检查一个唯一的对话框ID然后创建和定义相应的对话框。比如,想象一下一个游戏使用两个不同的对话框:一个用来指示这个游戏已经暂停而另一个来指示游戏结束。首先,为每个对话框定义一个常量:

  1. static final int DIALOG_PAUSED_ID = 0; 
  2. static final int DIALOG_GAMEOVER_ID = 1; 

然后,为每一个ID用一个switch case定义这个onCreateDialog(int) 回调函数:

  1. protected Dialog onCreateDialog(int id) { 
  2.     Dialog dialog; 
  3.     switch(id) { 
  4.     case DIALOG_PAUSED_ID: 
  5.         // do the work to define the pause Dialog 
  6.         break; 
  7.     case DIALOG_GAMEOVER_ID: 
  8.         // do the work to define the game over Dialog 
  9.         break; 
  10.     default: 
  11.         dialog = null; 
  12.     } 
  13.     return dialog; 

当是时候显示其中之一的对话框时,使用对话框ID调用showDialog(int):

  1. showDialog(DIALOG_PAUSED_ID); 

 

消除对话框Dismissing a Dialog

  
 当你准备关闭对话框时,你可以通过对这个对话框调用dismiss()来消除它。如果需要,你还可以从这个Activity中调用dismissDialog(int
id) 方法,这实际上将为你对这个对话框调用dismiss() 方法。

    如果你想使用onCreateDialog(int
id) 方法来管理你对话框的状态(就如同在前面的章节讨论的那样),然后每次你的对话框消除的时候,这个对话框对象的状态将由该Activity保留。如果你决定不再需要这个对象或者清除该状态是重要的,那么你应该调用removeDialog(int
id)。这将删除任何内部对象引用而且如果这个对话框正在显示,它将被消除。

 

使用消除侦听器Using dismiss listeners

  
 如果你希望你的应用程序在一个对话框消亡的时候执行一些流程,那么你应该附着一个on-dismiss侦听器到对话框上。

  1. @Override 
  2. protected void onPrepareDialog(int id, Dialog dialog) { 
  3.     switch(id){ 
  4.     case PROGRESS_DIALOG: 
  5.         dialog.setOnDismissListener(new DialogInterface.OnDismissListener(){ 
  6.             @Override 
  7.             public void onDismiss(DialogInterface dialog) { 
  8.                 Toast.makeText(getApplicationContext(), 
  9.                         “dismiss listener!”, 
  10.                         Toast.LENGTH_SHORT) 
  11.                 .show(); 
  12.             } 
  13.         }); 
  14.     } 

    然而,
请注意对话框也可以被“取消”。这是一个表明对话框被用户显示取消的特殊情况。这将在用户按“返回”按钮时发生,或者这个对话框显示的调用cancel() (也许通过对话框上的一个“取消”按钮)。当一个对话框被取消时,这个OnDismissListener
依然会被通知到,但是如果你希望在对话框被显示取消时被通知到(而不是通常的消除方式),那么你应该通过setOnCancelListener()注册一个DialogInterface.OnCancelListener 。

  
 目前个人学习发现,一般情况下,调用dialog.cancel()就会触发onCancelLister。而点击AlertDialog的NegativeButton
(Cancel/No)是不会触发的。对于setOnCancelListener()要注意的是,这里有两个setOnCancelListener(),但返回值不同:

  1. //AlertDialog.Builder调用的 
  2. public AlertDialog.Builder setOnCancelListener (DialogInterface.OnCancelListener onCancelListener) 
  3.  
  4. //Dialog调用的 
  5. public void setOnCancelListener (DialogInterface.OnCancelListener listener) 

 

警告对话框AlertDialog的使用

  
 为了创建一个警告对话框,使用AlertDialog.Builder 子类。通过AlertDialog.Builder(Context)获取一个构造器然后使用这个类的公共方法来定义警告对话框的所有属性。当得到构造器后,通过create().方法来获取警告对话框对象。有时我是不调用create()的,而是在设置好了后直接调用show()显示AlertDialog。

图片 7 图片 8 图片 9

增加按钮Adding buttons

  
 这就是我一开始很想知道的究竟如何添加Yes/No,Ok/Cancel这样的按钮。原来是通过setPositiveButton(…)响应Yes/Ok的点击,setNeutralButton(…)响应中立行为的点击,setNegativeButton(…)响应No/Cancel的点击。注意,只能各自设置一个按钮来响应点击事件。

  1. AlertDialog.Builder builder = new AlertDialog.Builder(this); 
  2. builder.setMessage(“Are you sure you want to exit?”) 
  3.        .setCancelable(false) 
  4.        .setPositiveButton(“Yes”, new DialogInterface.OnClickListener() { 
  5.            public void onClick(DialogInterface dialog, int id) { 
  6.                 MyActivity.this.finish(); 
  7.            } 
  8.        }) 
  9.        .setNegativeButton(“No”, new DialogInterface.OnClickListener() { 
  10.            public void onClick(DialogInterface dialog, int id) { 
  11.                 dialog.cancel(); 
  12.            } 
  13.        }); 
  14. AlertDialog alert = builder.create(); 

  
 首先,为这个对话框添加一个消息setMessage(CharSequence)。然后,开始函数链并设置该对话框为不能取消not
cancelable (因此用户不能使用返回按钮关闭这个对话框)。对每个按钮,使用任一set…Button()
方法,比如setPositiveButton(),该方法接受按钮名称以及一个定义用户选中按钮后所采取动作的DialogInterface.OnClickListener。

增加一个列表Adding a list
  1. final CharSequence[] items = {“Red”, “Green”, “Blue”}; 
  2.   
  3. AlertDialog.Builder builder = new AlertDialog.Builder(this); 
  4. builder.setTitle(“Pick a color”); 
  5. builder.setItems(items, new DialogInterface.OnClickListener() { 
  6.     public void onClick(DialogInterface dialog, int item) { 
  7.         Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show(); 
  8.     } 
  9. }); 
  10. AlertDialog alert = builder.create(); 

  
 首先,用setTitle(CharSequence)方法给对话框添加一个标题。然后,添加用setItems()添加一个可选项列表,该列表接受一组显示的items和一个DialogInterface.OnClickListener
来定义用户选中按钮后所采取动作。

增加复选框和单选按钮

    要在对话框里创建一个多选项列表(checkboxes)或者单选项(radio
buttons),可分别调用setMultiChoiceItems() 和setSingleChoiceItems() 方法。如果你在onCreateDialog()回调函数中创建这些可选列表,Android会帮你管理列表状态。只要这个活动是激活的,对话框会记住之前选中的items,但如果用户退出这个活动,用户选择将丢失。

    注意:
为了在用户离开或暂停这个活动的时候能够保存选择,你必须通过活动生命期Activity
Lifecycle来恰当的保存和恢复设置。为了永久保存选项,即使活动进程被完全终止,你需要使用数据存储Data
Storage技术。

  1. final CharSequence[] items = {“Red”, “Green”, “Blue”}; 
  2.   
  3. AlertDialog.Builder builder = new AlertDialog.Builder(this); 
  4. builder.setTitle(“Pick a color”); 
  5. builder.setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() { 
  6.     public void onClick(DialogInterface dialog, int item) { 
  7.         Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show(); 
  8.     } 
  9. }); 
  10. AlertDialog alert = builder.create(); 

  
 setSingleChoiceItems() 的第二个参数是一个checkedItem整型数值,指示了基于0的缺省选择项的位置。“-1”代表不会有默认选择项。

 

进度对话框Progress Dialog的使用

  
 ProgressDialog是AlertDialog类的一个扩展,可以为一个未定义进度的任务显示一个旋转轮形状的进度动画,或者为一个指定进度的任务显示一个进度条。

  
 可以简单地通过调用ProgressDialog.show()方法来显示一个进度对话框,而通过onCreateDialog(int)回调管理这个对话框是可选的,如下所示:

  1. ProgressDialog.show(this, // context 
  2.     “”, // title 
  3.     “Loading. Please wait…”, // message 
  4.     true); //进度是否是不确定的,这只和创建进度条有关 

进度对话框的缺省类型是一个旋转轮,运行看到的是以下效果:

图片 10

    

 

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注