Android系统原理与源码分析：利用Java反射技术阻止通过按钮关闭对话框

Question

转：疯狂の小石子

Android系统原理与源码分析：利用Java反射技术阻止通过按钮关闭对话框

  众所周知，AlertDialog类用于显示对话框。关于AlertDialog的基本用法在这里就不详细介绍了，网上有很多，读者可以自己搜索。那么本文要介绍的是如何随心所欲地控制AlertDialog。
    现在我们来看看第一个需求：如果某个应用需要弹出一个对话框。当单击“确定“按钮时完成某些工作，如果这些工作失败，对话框不能关闭。而当成功完成工作后，则关闭对话框。当然，无论何程度情况，单击“取消”按钮都会关闭对话框。
    这个需求并不复杂，也并不过分（虽然我们可以自己弄个Activity来完成这个工作，也可在View上自己放按钮，但这显示有些大炮打蚊子了，如果对话框上只有一行文本，费这么多劲太不值了）。但使用过AlertDialog的读者都知道，无论单击的哪个按钮，无论按钮单击事件的执行情况如何，对话框是肯定要关闭的。也就是说，用户无法控制对话框的关闭动作。实际上，关闭对话框的动作已经在Android SDK写死了，并且未给使用者留有任何接口。但我的座右铭是“宇宙中没有什么是不能控制的”。
    既然要控制对放框的关闭行为，首先就得分析是哪些类、哪些代码使这个对话框关闭的。进入AlertDialog类的源代码。在AlertDialog中只定义了一个变量：mAlert。这个变量是AlertController类型。AlertController类是Android的内部类，在com.android.internal.app包中，无法通过普通的方式访问。也无法在Eclipse中通过按Ctrl键跟踪进源代码。但可以直接在Android源代码中找到AlertController.java。我们再回到AlertDialog类中。AlertDialog类实际上只是一个架子。象设置按钮、设置标题等工作都是由AlertController类完成的。因此，AlertController类才是关键。
    找到AlertController.java文件。打开后不要感到头晕哦，这个文件中的代码是很多地。不过这么多代码对本文的主题也没什么用处。下面就找一下控制按钮的代码。
    在AlertController类的开头就会看到如下的代码：

2.    View.OnClickListener mButtonHandler  =   new  View.OnClickListener() {
3.          public   void  onClick(View v) {
4.             Message m  =   null ;
5.              if  (v  ==  mButtonPositive  &&  mButtonPositiveMessage  !=   null ) {
6.                 m  =  Message.obtain(mButtonPositiveMessage);
7.             }  else   if  (v  ==  mButtonNegative  &&  mButtonNegativeMessage  !=   null ) {
8.                 m  =  Message.obtain(mButtonNegativeMessage);
9.             }  else   if  (v  ==  mButtonNeutral  &&  mButtonNeutralMessage  !=   null ) {
10.                 m  =  Message.obtain(mButtonNeutralMessage);
11.             }
12.              if  (m  !=   null ) {
13.                 m.sendToTarget();
14.             }
16.              //  Post a message so we dismiss after the above handlers are executed
17.             mHandler.obtainMessage(ButtonHandler.MSG_DISMISS_DIALOG, mDialogInterface)
18.                     .sendToTarget();
19.         }
20.     };

复制代码从这段代码中可以猜出来，前几行代码用来触发对话框中的三个按钮（ Positive 、 Negative 和 Neutral ）的单击事件，而最后的代码则用来关闭对话框（因为我们发现了 MSG_DISMISS_DIALOG 、猜出来的）。

mHandler.obtainMessage(ButtonHandler.MSG_DISMISS_DIALOG, mDialogInterface)
                    .sendToTarget();
上面的代码并不是直接来关闭对话框的，而是通过一个 Handler 来处理，代码如下：

1. private   static   final   class  ButtonHandler  extends  Handler {
2.          //  Button clicks have Message.what as the BUTTON{1,2,3} constant
3.          private   static   final   int  MSG_DISMISS_DIALOG  =   1 ;
4.         
5.          private  WeakReference < DialogInterface >  mDialog;
7.          public  ButtonHandler(DialogInterface dialog) {
8.             mDialog  =   new  WeakReference < DialogInterface > (dialog);
9.         }
11.         @Override
12.          public   void  handleMessage(Message msg) {
13.              switch  (msg.what) {
14.                
15.                  case  DialogInterface.BUTTON_POSITIVE:
16.                  case  DialogInterface.BUTTON_NEGATIVE:
17.                  case  DialogInterface.BUTTON_NEUTRAL:
18.                     ((DialogInterface.OnClickListener) msg.obj).onClick(mDialog.get(), msg.what);
19.                      break ;
20.                     
21.                  case  MSG_DISMISS_DIALOG:
22.                     ((DialogInterface) msg.obj).dismiss();
23.             }
24.         }
25.     }

复制代码从上面代码的最后可以找到  ((DialogInterface) msg.obj).dismiss();。现在看了这么多源代码，我们来总结一下对话框按钮单击事件的处理过程。在AlertController处理对话框按钮时会为每一个按钮添加一个onclick事件。而这个事件类的对象实例就是上面的mButtonHandler。在这个单击事件中首先会通过发送消息的方式调用为按钮设置的单击事件（也就是通过setPositiveButton等方法的第二个参数设置的单击事件），在触发完按钮的单击事件后，会通过发送消息的方式调用dismiss方法来关闭对话框。而在AlertController类中定义了一个全局的mHandler变量。在AlertController类中通过ButtonHandler类来对象来为mHandler赋值。因此，我们只要使用我们自己Handler对象替换ButtonHandler就可以阻止调用dismiss方法来关闭对话框。下面先在自己的程序中建立一个新的ButtonHandler类（也可叫其他的名）。

1. class  ButtonHandler  extends  Handler
2. {
4.      private  WeakReference < DialogInterface >  mDialog;
6.      public  ButtonHandler(DialogInterface dialog)
7.     {
8.         mDialog  =   new  WeakReference < DialogInterface > (dialog);
9.     }
11.     @Override
12.      public   void  handleMessage(Message msg)
13.     {
14.          switch  (msg.what)
15.         {
17.              case  DialogInterface.BUTTON_POSITIVE:
18.              case  DialogInterface.BUTTON_NEGATIVE:
19.              case  DialogInterface.BUTTON_NEUTRAL:
20.                 ((DialogInterface.OnClickListener) msg.obj).onClick(mDialog
21.                         .get(), msg.what);
22.                  break ;
23.         }
24.     }
25. }

复制代码我们可以看到，上面的类和AlertController中的ButtonHandler类很像，只是支掉了switch语句的最后一个case子句（用于调用dismiss方法）和相关的代码。
    下面我们就要为AlertController中的mHandler重新赋值。由于mHandler是private变量，因此，在这里需要使用Java的反射技术来为mHandler赋值。由于在AlertDialog类中的mAlert变量同样也是private，因此，也需要使用同样的反射技术来获得mAlert变量。代码如下：

先建立一个 AlertDialog 对象

2. AlertDialog alertDialog  =   new  AlertDialog.Builder( this )
3.         .setTitle( " abc " )
4.         .setMessage( " content " )
5.         .setIcon(R.drawable.icon)
6.         .setPositiveButton( “确定”,
7.                  new  OnClickListener()
8.                 {
9.                     @Override
10.                      public   void  onClick(DialogInterface dialog,
11.                              int  which)
12.                     {
14.                     }
15.                 }).setNegativeButton( " 取消 " ,  new  OnClickListener()
16.         {
18.             @Override
19.              public   void  onClick(DialogInterface dialog,  int  which)
20.             {
21.                 dialog.dismiss();
22.             }
23.         }).create()

复制代码上面的对话框很普通，单击哪个按钮都会关闭对话框。下面在调用 show 方法之前来修改一个 mHandler 变量的值， OK ，下面我们就来见证奇迹的时刻。

1. try  
2.         {
3.            
4.             Field field  =  alertDialog1.getClass().getDeclaredField( " mAlert " );
5.             field.setAccessible( true );
6.             //   获得mAlert变量的值
7.             Object obj  =  field.get(alertDialog1);
8.             field  =  obj.getClass().getDeclaredField( " mHandler " );
9.             field.setAccessible( true );
10.             //   修改mHandler变量的值，使用新的ButtonHandler类
11.             field.set(obj,  new  ButtonHandler(alertDialog1));
12.         }
13.          catch  (Exception e)
14.         {
15.         }
16.        //   显示对话框
17.       alertDialog.show();

复制代码我们发现，如果加上try   catch语句，单击对话框中的确定按钮不会关闭对话框（除非在代码中调用dismiss方法），单击取消按钮则会关闭对话框（因为调用了dismiss方法）。如果去了try…catch代码段，对话框又会恢复正常了。
    虽然上面的代码已经解决了问题，但需要编写的代码仍然比较多，为此，我们也可采用另外一种方法来阻止关闭对话框。这种方法不需要定义任何的类。
    这种方法需要用点技巧。由于系统通过调用dismiss来关闭对话框，那么我们可以在dismiss方法上做点文章。在系统调用dismiss方法时会首先判断对话框是否已经关闭，如果对话框已经关闭了，就会退出dismiss方法而不再继续关闭对话框了。因此，我们可以欺骗一下系统，当调用dismiss方法时我们可以让系统以为对话框已经关闭（虽然对话框还没有关闭），这样dismiss方法就失效了，这样即使系统调用了dismiss方法也无法关闭对话框了。
    下面让我们回到AlertDialog的源代码中，再继续跟踪到AlertDialog的父类Dialog的源代码中。找到dismissDialog方法。实际上，dismiss方法是通过dismissDialog方法来关闭对话框的，dismissDialog方法的代码如下：

1. private   void  dismissDialog() {
2.          if  (mDecor  ==   null ) {
3.              if  (Config.LOGV) Log.v(LOG_TAG,
4.                      " [Dialog] dismiss: already dismissed, ignore " );
5.              return ;
6.         }
7.          if  ( ! mShowing) {
8.              if  (Config.LOGV) Log.v(LOG_TAG,
9.                      " [Dialog] dismiss: not showing, ignore " );
10.              return ;
11.         }
13.         mWindowManager.removeView(mDecor);
15.         mDecor  =   null ;
16.         mWindow.closeAllPanels();
17.         onStop();
18.         mShowing  =   false ;
19.         
20.         sendDismissMessage();
21.     }

复制代码该方法后面的代码不用管它，先看 if(!mShowing){ … } 这段代码。这个 mShowing 变量就是判断对话框是否已关闭的。因此，我们在代码中通过设置这个变量就可以使系统认为对话框已经关闭，就不再继续关闭对话框了。由于 mShowing 也是 private 变量，因此，也需要反射技术来设置这个变量。我们可以在对话框按钮的单击事件中设置 mShowing ，代码如下：

1. try
2. {
3.     Field field  =  dialog.getClass()
4.             .getSuperclass().getDeclaredField(
5.                      " mShowing " );
6.     field.setAccessible( true );
7.      //   将mShowing变量设为false，表示对话框已关闭
8.     field.set(dialog,  false );
9.     dialog.dismiss();
11. }
12. catch  (Exception e)
13. {
15. }

复制代码将上面的代码加到哪个按钮的单击事件代码中，哪个按钮就再也无法关闭对话框了。如果要关闭对话框，只需再将 mShowing 设为 true 即可。要注意的是，在一个按钮里设置了 mShowing 变量，也会影响另一个按钮的关闭对话框功能，因此，需要在每一个按钮的单击事件里都设置 mShowing 变量的值。

从本文可以看出，虽然使用普通方法控制对话框的某些功能，但通过反射技术可以很容易地做到看似不可能完成的任务。当然，除了控制对话框的关闭功能外，还可以控制对话框其他的行为，剩下的就靠读者自己挖掘了。