Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright (C) 2006 The Android Open Source Project
3
    *
4
    * Licensed under the Apache License, Version 2.0 (the "License");
5
    * you may not use this file except in compliance with the License.
6
    * You may obtain a copy of the License at
7
    *
8
    *      http://www.apache.org/licenses/LICENSE-2.0
9
    *
10
   * Unless required by applicable law or agreed to in writing, software
11
   * distributed under the License is distributed on an "AS IS" BASIS,
12
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
   * See the License for the specific language governing permissions and
14
   * limitations under the License.
15
   */
16
  
17
  package android.app;
18
  
20
  
26
  import android.net.Uri;
27
  import android.os.Bundle;
35
  import android.view.Menu;
38
  import android.view.View;
47
  
Base class for Dialogs.

Note: Activities provide a facility to manage the creation, saving and restoring of dialogs. See Activity.onCreateDialog(int), Activity.onPrepareDialog(int,android.app.Dialog), Activity.showDialog(int), and Activity.dismissDialog(int). If these methods are used, getOwnerActivity() will return the Activity that managed this dialog.

Often you will want to have a Dialog display on top of the current input method, because there is no reason for it to accept text. You can do this by setting the WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM window flag (assuming your Dialog takes input focus, as it the default) with the following code: 

     getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
             WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
 
70
  
71
  public class Dialog implements DialogInterface, Window.Callback,
73
      private Activity mOwnerActivity;
74
      
75
      final Context mContext;
76
      final WindowManager mWindowManager;
77
      Window mWindow;
78
      View mDecor;
    
This field should be made private, so it is hidden from the SDK. 
82
  
83
      protected boolean mCancelable = true;
84
  
85
      private Message mCancelMessage;
86
      private Message mDismissMessage;
87
      private Message mShowMessage;

    
Whether to cancel the dialog when a touch is received outside of the window's bounds. 
92
  
93
      private boolean mCanceledOnTouchOutside = false;
94
      
95
      private OnKeyListener mOnKeyListener;
96
  
97
      private boolean mCreated = false;
98
      private boolean mShowing = false;
99
  
100
     private final Thread mUiThread;
101
     private final Handler mHandler = new Handler();
102
 
103
     private static final int DISMISS = 0x43;
104
     private static final int CANCEL = 0x44;
105
     private static final int SHOW = 0x45;
106
 
107
     private Handler mListenersHandler;
108
 
109
     private final Runnable mDismissAction = new Runnable() {
110
         public void run() {
111
             dismissDialog();
112
         }
113
     };

    
Create a Dialog window that uses the default dialog frame style.

Parameters:
context The Context the Dialog is to run it. In particular, it uses the window manager and theme in this context to present its UI.
121
 
122
     public Dialog(Context context) {
123
         this(context, 0);
124
     }

    
Create a Dialog window that uses a custom dialog style.

Parameters:
context The Context in which the Dialog should run. In particular, it uses the window manager and theme from this context to present its UI.
theme A style resource describing the theme to use for the window. See Style and Theme Resources for more information about defining and using styles. This theme is applied on top of the current theme in context. If 0, the default dialog theme will be used.
137
 
138
     public Dialog(Context context, int theme) {
139
          = new ContextThemeWrapper(
140
             context, theme == 0 ? ..... : theme);
141
          = (WindowManager)context.getSystemService("window");
142
         Window w = PolicyManager.makeNewWindow();
143
          = w;
144
         w.setCallback(this);
145
         w.setWindowManager(, null, null);
146
         w.setGravity(.);
147
          = Thread.currentThread();
148
          = new ListenersHandler(this);
149
     }

    

Deprecated:
Hide:
154
 
155
     @Deprecated
156
     protected Dialog(Context context, boolean cancelable,
157
             Message cancelCallback) {
158
         this(context);
159
          = cancelable;
160
          = cancelCallback;
161
     }
162
 
163
     protected Dialog(Context context, boolean cancelable,
164
             OnCancelListener cancelListener) {
165
         this(context);
166
          = cancelable;
167
         setOnCancelListener(cancelListener);
168
     }

    
Retrieve the Context this Dialog is running in.

Returns:
Context The Context that was supplied to the constructor.
174
 
175
     public final Context getContext() {
176
         return ;
177
     }

    
Sets the Activity that owns this dialog. An example use: This Dialog will use the suggested volume control stream of the Activity.

Parameters:
activity The Activity that owns this dialog.
184
 
185
     public final void setOwnerActivity(Activity activity) {
186
          = activity;
187
         
189
     }

    
Returns the Activity that owns this Dialog. For example, if Activity.showDialog(int) is used to show this Dialog, that Activity will be the owner (by default). Depending on how this dialog was created, this may return null.

Returns:
The Activity that owns this Dialog.
198
 
199
     public final Activity getOwnerActivity() {
200
         return ;
201
     }
    
    

Returns:
Whether the dialog is currently showing.
205
 
206
     public boolean isShowing() {
207
         return ;
208
     }

    
Start the dialog and display it on screen. The window is placed in the application layer and opaque. Note that you should not override this method to do initialization when the dialog is shown, instead implement that in onStart(). 
215
 
216
     public void show() {
217
         if () {
218
             if ( != null) {
219
                 .setVisibility(.);
220
             }
221
             return;
222
         }
223
 
224
         if (!) {
225
             dispatchOnCreate(null);
226
         }
227
 
228
         onStart();
229
          = .getDecorView();
231
         if ((l.softInputMode
232
                 & ..) == 0) {
233
             WindowManager.LayoutParams nl = new WindowManager.LayoutParams();
234
             nl.copyFrom(l);
235
             nl.softInputMode |=
236
                     ..;
237
             l = nl;
238
         }
239
 
240
         try {
241
             .addView(, l);
242
              = true;
243
     
244
             sendShowMessage();
245
         } finally {
246
         }
247
     }
    
    
Hide the dialog, but do not dismiss it. 
251
 
252
     public void hide() {
253
         if ( != null) {
254
             .setVisibility(.);
255
         }
256
     }

    
Dismiss this dialog, removing it from the screen. This method can be invoked safely from any thread. Note that you should not override this method to do cleanup when the dialog is dismissed, instead implement that in onStop(). 
263
 
264
     public void dismiss() {
265
         if (Thread.currentThread() != ) {
266
             .post();
267
         } else {
268
             .run();
269
         }
270
     }
271
 
272
     private void dismissDialog() {
273
         if ( == null || !) {
274
             return;
275
         }
276
 
277
         try {
278
             .removeView();
279
         } finally {
280
              = null;
281
             .closeAllPanels();
282
             onStop();
283
              = false;
284
             
285
             sendDismissMessage();
286
         }
287
     }
288
 
289
     private void sendDismissMessage() {
290
         if ( != null) {
291
             // Obtain a new message so this dialog can be re-used
292
             Message.obtain().sendToTarget();
293
         }
294
     }
295
 
296
     private void sendShowMessage() {
297
         if ( != null) {
298
             // Obtain a new message so this dialog can be re-used
299
             Message.obtain().sendToTarget();
300
         }
301
     }
302
 
303
     // internal method to make sure mcreated is set properly without requiring
304
     // users to call through to super in onCreate
305
     void dispatchOnCreate(Bundle savedInstanceState) {
306
         if (!) {
307
             onCreate(savedInstanceState);
308
              = true;
309
         }
310
     }

    
Similar to Activity.onCreate(android.os.Bundle), you should initialized your dialog in this method, including calling setContentView(int).

Parameters:
savedInstanceState If this dialog is being reinitalized after a the hosting activity was previously shut down, holds the result from the most recent call to onSaveInstanceState(), or null if this is the first time.
319
 
320
     protected void onCreate(Bundle savedInstanceState) {
321
     }

    
Called when the dialog is starting. 
325
 
326
     protected void onStart() {
327
     }

    
Called to tell you that you're stopping. 
331
 
332
     protected void onStop() {
333
     }
334
 
335
     private static final String DIALOG_SHOWING_TAG = "android:dialogShowing";
336
     private static final String DIALOG_HIERARCHY_TAG = "android:dialogHierarchy";

    
Saves the state of the dialog into a bundle. The default implementation saves the state of its view hierarchy, so you'll likely want to call through to super if you override this to save additional state.

Returns:
A bundle with the state of the dialog.
345
 
346
     public Bundle onSaveInstanceState() {
347
         Bundle bundle = new Bundle();
348
         bundle.putBoolean(, );
349
         if () {
350
             bundle.putBundle(, .saveHierarchyState());
351
         }
352
         return bundle;
353
     }

    
Restore the state of the dialog from a previously saved bundle. The default implementation restores the state of the dialog's view hierarchy that was saved in the default implementation of onSaveInstanceState(), so be sure to call through to super when overriding unless you want to do all restoring of state yourself.

Parameters:
savedInstanceState The state of the dialog previously saved by onSaveInstanceState().
364
 
365
     public void onRestoreInstanceState(Bundle savedInstanceState) {
366
         final Bundle dialogHierarchyState = savedInstanceState.getBundle();
367
         if (dialogHierarchyState == null) {
368
             // dialog has never been shown, or onCreated, nothing to restore.
369
             return;
370
         }
371
         dispatchOnCreate(savedInstanceState);
372
         .restoreHierarchyState(dialogHierarchyState);
373
         if (savedInstanceState.getBoolean()) {
374
             show();
375
         }
376
     }

    
Retrieve the current Window for the activity. This can be used to directly access parts of the Window API that are not available through Activity/Screen.

Returns:
Window The current window, or null if the activity is not visual.
385
 
386
     public Window getWindow() {
387
         return ;
388
     }

    
Call android.view.Window.getCurrentFocus() on the Window if this Activity to return the currently focused view.

Returns:
View The current View with focus or null.
See also:
getWindow()
android.view.Window.getCurrentFocus()
398
 
399
     public View getCurrentFocus() {
400
         return  != null ? .getCurrentFocus() : null;
401
     }

    
Finds a view that was identified by the id attribute from the XML that was processed in onStart().

Parameters:
id the identifier of the view to find
Returns:
The view if found or null otherwise.
409
 
410
     public View findViewById(int id) {
411
         return .findViewById(id);
412
     }

    
Set the screen content from a layout resource. The resource will be inflated, adding all top-level views to the screen.

Parameters:
layoutResID Resource ID to be inflated.
419
 
420
     public void setContentView(int layoutResID) {
421
         .setContentView(layoutResID);
422
     }

    
Set the screen content to an explicit view. This view is placed directly into the screen's view hierarchy. It can itself be a complex view hierarhcy.

Parameters:
view The desired content to display.
430
 
431
     public void setContentView(View view) {
432
         .setContentView(view);
433
     }

    
Set the screen content to an explicit view. This view is placed directly into the screen's view hierarchy. It can itself be a complex view hierarhcy.

Parameters:
view The desired content to display.
params Layout parameters for the view.
442
 
443
     public void setContentView(View view, ViewGroup.LayoutParams params) {
444
         .setContentView(view, params);
445
     }

    
Add an additional content view to the screen. Added after any existing ones in the screen -- existing views are NOT removed.

Parameters:
view The desired content to display.
params Layout parameters for the view.
453
 
454
     public void addContentView(View view, ViewGroup.LayoutParams params) {
455
         .addContentView(view, params);
456
     }

    
Set the title text for this dialog's window.

Parameters:
title The new text to display in the title.
462
 
463
     public void setTitle(CharSequence title) {
464
         .setTitle(title);
465
         .getAttributes().setTitle(title);
466
     }

    
Set the title text for this dialog's window. The text is retrieved from the resources with the supplied identifier.

Parameters:
titleId the title's text resource identifier
473
 
474
     public void setTitle(int titleId) {
475
         setTitle(.getText(titleId));
476
     }

    
A key was pressed down.

If the focused view didn't want this event, this method is called.

The default implementation consumed the KEYCODE_BACK to later handle it in onKeyUp(int,android.view.KeyEvent).

See also:
onKeyUp(int,android.view.KeyEvent)
android.view.KeyEvent
488
 
489
     public boolean onKeyDown(int keyCode, KeyEvent event) {
490
         if (keyCode == .) {
491
             event.startTracking();
492
             return true;
493
         }
494
 
495
         return false;
496
     }

    
Default implementation of KeyEvent.Callback.onKeyLongPress(): always returns false (doesn't handle the event). 
502
 
503
     public boolean onKeyLongPress(int keyCode, KeyEvent event) {
504
         return false;
505
     }

    
A key was released.

The default implementation handles KEYCODE_BACK to close the dialog.

See also:
onKeyDown(int,android.view.KeyEvent)
android.view.KeyEvent
515
 
516
     public boolean onKeyUp(int keyCode, KeyEvent event) {
517
         if (keyCode == . && event.isTracking()
518
                 && !event.isCanceled()) {
519
             onBackPressed();
520
             return true;
521
         }
522
         return false;
523
     }

    
Default implementation of KeyEvent.Callback.onKeyMultiple(): always returns false (doesn't handle the event). 
529
 
530
     public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
531
         return false;
532
     }
    
    
Called when the dialog has detected the user's press of the back key. The default implementation simply cancels the dialog (only if it is cancelable), but you can override this to do whatever you want. 
538
 
539
     public void onBackPressed() {
540
         if () {
541
             cancel();
542
         }
543
     }
    
    
Called when a touch screen event was not handled by any of the views under it. This is most useful to process touch events that happen outside of your window bounds, where there is no view to receive it.

Parameters:
event The touch screen event being processed.
Returns:
Return true if you have consumed the event, false if you haven't. The default implementation will cancel the dialog when a touch happens outside of the window bounds.
554
 
555
     public boolean onTouchEvent(MotionEvent event) {
556
         if ( &&  && event.getAction() == .
557
                 && isOutOfBounds(event)) {
558
             cancel();
559
             return true;
560
         }
561
         
562
         return false;
563
     }
564
 
565
     private boolean isOutOfBounds(MotionEvent event) {
566
         final int x = (int) event.getX();
567
         final int y = (int) event.getY();
568
         final int slop = ViewConfiguration.get().getScaledWindowTouchSlop();
569
         final View decorView = getWindow().getDecorView();
570
         return (x < -slop) || (y < -slop)
571
                 || (x > (decorView.getWidth()+slop))
572
                 || (y > (decorView.getHeight()+slop));
573
     }
    
    
Called when the trackball was moved and not handled by any of the views inside of the activity. So, for example, if the trackball moves while focus is on a button, you will receive a call here because buttons do not normally do anything with trackball events. The call here happens before trackball movements are converted to DPAD key events, which then get sent back to the view hierarchy, and will be processed at the point for things like focus navigation.

Parameters:
event The trackball event being processed.
Returns:
Return true if you have consumed the event, false if you haven't. The default implementation always returns false.
588
 
589
     public boolean onTrackballEvent(MotionEvent event) {
590
         return false;
591
     }
592
     
593
     public void onWindowAttributesChanged(WindowManager.LayoutParams params) {
594
         if ( != null) {
595
             .updateViewLayout(, params);
596
         }
597
     }
598
 
599
     public void onContentChanged() {
600
     }
601
     
602
     public void onWindowFocusChanged(boolean hasFocus) {
603
     }
604
 
605
     public void onAttachedToWindow() {
606
     }
607
     
608
     public void onDetachedFromWindow() {
609
     }
    
    
Called to process key events. You can override this to intercept all key events before they are dispatched to the window. Be sure to call this implementation for key events that should be handled normally.

Parameters:
event The key event.
Returns:
boolean Return true if this event was consumed.
619
 
620
     public boolean dispatchKeyEvent(KeyEvent event) {
621
         if (( != null) && (.onKey(this, event.getKeyCode(), event))) {
622
             return true;
623
         }
624
         if (.superDispatchKeyEvent(event)) {
625
             return true;
626
         }
627
         return event.dispatch(this,  != null
628
                 ? .getKeyDispatcherState() : null, this);
629
     }

    
Called to process touch screen events. You can override this to intercept all touch screen events before they are dispatched to the window. Be sure to call this implementation for touch screen events that should be handled normally.

Parameters:
ev The touch screen event.
Returns:
boolean Return true if this event was consumed.
640
 
641
     public boolean dispatchTouchEvent(MotionEvent ev) {
642
         if (.superDispatchTouchEvent(ev)) {
643
             return true;
644
         }
645
         return onTouchEvent(ev);
646
     }
    
    
Called to process trackball events. You can override this to intercept all trackball events before they are dispatched to the window. Be sure to call this implementation for trackball events that should be handled normally.

Parameters:
ev The trackball event.
Returns:
boolean Return true if this event was consumed.
657
 
658
     public boolean dispatchTrackballEvent(MotionEvent ev) {
659
         if (.superDispatchTrackballEvent(ev)) {
660
             return true;
661
         }
662
         return onTrackballEvent(ev);
663
     }
664
 
665
     public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
666
         event.setClassName(getClass().getName());
667
         event.setPackageName(.getPackageName());
668
 
669
         LayoutParams params = getWindow().getAttributes();
670
         boolean isFullScreen = (params.width == .) &&
671
             (params.height == .);
672
         event.setFullScreen(isFullScreen);
673
 
674
         return false;
675
     }

    

See also:
Activity.onCreatePanelView(int)
679
 
680
     public View onCreatePanelView(int featureId) {
681
         return null;
682
     }

    

See also:
Activity.onCreatePanelMenu(int,android.view.Menu)
686
 
687
     public boolean onCreatePanelMenu(int featureId, Menu menu) {
688
         if (featureId == .) {
689
             return onCreateOptionsMenu(menu);
690
         }
691
         
692
         return false;
693
     }

    

See also:
Activity.onPreparePanel(int,android.view.View,android.view.Menu)
697
 
698
     public boolean onPreparePanel(int featureId, View view, Menu menu) {
699
         if (featureId == . && menu != null) {
700
             boolean goforit = onPrepareOptionsMenu(menu);
701
             return goforit && menu.hasVisibleItems();
702
         }
703
         return true;
704
     }

    

See also:
Activity.onMenuOpened(int,android.view.Menu)
708
 
709
     public boolean onMenuOpened(int featureId, Menu menu) {
710
         return true;
711
     }

    

See also:
Activity.onMenuItemSelected(int,android.view.MenuItem)
715
 
716
     public boolean onMenuItemSelected(int featureId, MenuItem item) {
717
         return false;
718
     }

    

See also:
Activity.onPanelClosed(int,android.view.Menu)
722
 
723
     public void onPanelClosed(int featureId, Menu menu) {
724
     }

    
It is usually safe to proxy this call to the owner activity's Activity.onCreateOptionsMenu(android.view.Menu) if the client desires the same menu for this Dialog.

See also:
Activity.onCreateOptionsMenu(android.view.Menu)
getOwnerActivity()
733
 
734
     public boolean onCreateOptionsMenu(Menu menu) {
735
         return true;
736
     }

    
It is usually safe to proxy this call to the owner activity's Activity.onPrepareOptionsMenu(android.view.Menu) if the client desires the same menu for this Dialog.

See also:
Activity.onPrepareOptionsMenu(android.view.Menu)
getOwnerActivity()
745
 
746
     public boolean onPrepareOptionsMenu(Menu menu) {
747
         return true;
748
     }

    

See also:
Activity.onOptionsItemSelected(android.view.MenuItem)
752
 
753
     public boolean onOptionsItemSelected(MenuItem item) {
754
         return false;
755
     }

    

See also:
Activity.onOptionsMenuClosed(android.view.Menu)
759
 
760
     public void onOptionsMenuClosed(Menu menu) {
761
     }

    

See also:
Activity.openOptionsMenu()
765
 
766
     public void openOptionsMenu() {
768
     }
    
    

See also:
Activity.closeOptionsMenu()
772
 
773
     public void closeOptionsMenu() {
775
     }

    

See also:
Activity.onCreateContextMenu(android.view.ContextMenu,android.view.View,android.view.ContextMenu.ContextMenuInfo)
779
 
780
     public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
781
     }

    

See also:
Activity.registerForContextMenu(android.view.View)
785
 
786
     public void registerForContextMenu(View view) {
787
         view.setOnCreateContextMenuListener(this);
788
     }
    
    

See also:
Activity.unregisterForContextMenu(android.view.View)
792
 
793
     public void unregisterForContextMenu(View view) {
794
         view.setOnCreateContextMenuListener(null);
795
     }
    
    

See also:
Activity.openContextMenu(android.view.View)
799
 
800
     public void openContextMenu(View view) {
801
         view.showContextMenu();
802
     }

    

See also:
Activity.onContextItemSelected(android.view.MenuItem)
806
 
807
     public boolean onContextItemSelected(MenuItem item) {
808
         return false;
809
     }
    
    

See also:
Activity.onContextMenuClosed(android.view.Menu)
813
 
814
     public void onContextMenuClosed(Menu menu) {
815
     }
    
    
This hook is called when the user signals the desire to start a search. 
819
 
820
     public boolean onSearchRequested() {
821
         final SearchManager searchManager = (SearchManager) 
822
                 .getSystemService(.);
823
 
824
         // associate search with owner activity
825
         final ComponentName appName = getAssociatedActivity();
826
         if (appName != null) {
827
             searchManager.startSearch(null, false, appName, null, false);
828
             dismiss();
829
             return true;
830
         } else {
831
             return false;
832
         }
833
     }

    

Returns:
The activity associated with this dialog, or null if there is no assocaited activity.
837
 
838
     private ComponentName getAssociatedActivity() {
839
         Activity activity = ;
840
         Context context = getContext();
841
         while (activity == null && context != null) {
842
             if (context instanceof Activity) {
843
                 activity = (Activity) context;  // found it!
844
             } else {
845
                 context = (context instanceof ContextWrapper) ?
846
                         ((ContextWrapper) context).getBaseContext() : // unwrap one level
847
                         null;                                         // done
848
             }
849
         }
850
         return activity == null ? null : activity.getComponentName();
851
     }


    
Request that key events come to this dialog. Use this if your dialog has no views with focus, but the dialog still wants a chance to process key events.

Parameters:
get true if the dialog should receive key events, false otherwise
See also:
android.view.Window.takeKeyEvents(boolean)
861
 
862
     public void takeKeyEvents(boolean get) {
863
         .takeKeyEvents(get);
864
     }

    
Enable extended window features. This is a convenience for calling getWindow().requestFeature().

Parameters:
featureId The desired feature as defined in android.view.Window.
Returns:
Returns true if the requested feature is supported and now enabled.
See also:
android.view.Window.requestFeature(int)
876
 
877
     public final boolean requestWindowFeature(int featureId) {
878
         return getWindow().requestFeature(featureId);
879
     }

    
Convenience for calling android.view.Window.setFeatureDrawableResource(int,int). 
884
 
885
     public final void setFeatureDrawableResource(int featureId, int resId) {
886
         getWindow().setFeatureDrawableResource(featureId, resId);
887
     }

    
Convenience for calling android.view.Window.setFeatureDrawableUri(int,android.net.Uri). 
892
 
893
     public final void setFeatureDrawableUri(int featureId, Uri uri) {
894
         getWindow().setFeatureDrawableUri(featureId, uri);
895
     }

    
Convenience for calling android.view.Window.setFeatureDrawable(int,android.graphics.drawable.Drawable). 
900
 
901
     public final void setFeatureDrawable(int featureId, Drawable drawable) {
902
         getWindow().setFeatureDrawable(featureId, drawable);
903
     }

    
Convenience for calling android.view.Window.setFeatureDrawableAlpha(int,int). 
908
 
909
     public final void setFeatureDrawableAlpha(int featureId, int alpha) {
910
         getWindow().setFeatureDrawableAlpha(featureId, alpha);
911
     }
912
 
913
     public LayoutInflater getLayoutInflater() {
914
         return getWindow().getLayoutInflater();
915
     }

    
Sets whether this dialog is cancelable with the BACK key. 
920
 
921
     public void setCancelable(boolean flag) {
922
          = flag;
923
     }

    
Sets whether this dialog is canceled when touched outside the window's bounds. If setting to true, the dialog is set to be cancelable if not already set.

Parameters:
cancel Whether the dialog should be canceled when touched outside the window.
932
 
933
     public void setCanceledOnTouchOutside(boolean cancel) {
934
         if (cancel && !) {
935
              = true;
936
         }
937
         
938
          = cancel;
939
     }
    
    
Cancel the dialog. This is essentially the same as calling dismiss(), but it will also call your android.content.DialogInterface.OnCancelListener (if registered). 
944
 
945
     public void cancel() {
946
         if ( != null) {
947
             
948
             // Obtain a new message so this dialog can be re-used
949
             Message.obtain().sendToTarget();
950
         }
951
         dismiss();
952
     }

    
Set a listener to be invoked when the dialog is canceled.

This will only be invoked when the dialog is canceled, if the creator needs to know when it is dismissed in general, use setOnDismissListener(android.content.DialogInterface.OnDismissListener).

Parameters:
listener The android.content.DialogInterface.OnCancelListener to use.
962
 
963
     public void setOnCancelListener(final OnCancelListener listener) {
964
         if (listener != null) {
965
              = .obtainMessage(, listener);
966
         } else {
967
              = null;
968
         }
969
     }

    
Set a message to be sent when the dialog is canceled.

Parameters:
msg The msg to send when the dialog is canceled.
See also:
setOnCancelListener(android.content.DialogInterface.OnCancelListener)
975
 
976
     public void setCancelMessage(final Message msg) {
977
          = msg;
978
     }

    
Set a listener to be invoked when the dialog is dismissed.

Parameters:
listener The android.content.DialogInterface.OnDismissListener to use.
983
 
984
     public void setOnDismissListener(final OnDismissListener listener) {
985
         if (listener != null) {
986
              = .obtainMessage(, listener);
987
         } else {
988
              = null;
989
         }
990
     }

    
Sets a listener to be invoked when the dialog is shown.

Parameters:
listener The android.content.DialogInterface.OnShowListener to use.
995
 
996
     public void setOnShowListener(OnShowListener listener) {
997
         if (listener != null) {
998
              = .obtainMessage(, listener);
999
         } else {
1000
             = null;
1001
        }
1002
    }

    
Set a message to be sent when the dialog is dismissed.

Parameters:
msg The msg to send when the dialog is dismissed.
1008
    public void setDismissMessage(final Message msg) {
1009
         = msg;
1010
    }

    
By default, this will use the owner Activity's suggested stream type.

See also:
Activity.setVolumeControlStream(int)
setOwnerActivity(android.app.Activity)
1018
    public final void setVolumeControlStream(int streamType) {
1019
        getWindow().setVolumeControlStream(streamType);
1020
    }

    

See also:
Activity.getVolumeControlStream()
1025
    public final int getVolumeControlStream() {
1026
        return getWindow().getVolumeControlStream();
1027
    }
    
    
Sets the callback that will be called if a key is dispatched to the dialog. 
1032
    public void setOnKeyListener(final OnKeyListener onKeyListener) {
1033
         = onKeyListener;
1034
    }
1036
    private static final class ListenersHandler extends Handler {
1037
        private WeakReference<DialogInterface> mDialog;
1039
        public ListenersHandler(Dialog dialog) {
1040
             = new WeakReference<DialogInterface>(dialog);
1041
        }
1043
        @Override
1044
        public void handleMessage(Message msg) {
1045
            switch (msg.what) {
1046
                case :
1047
                    ((OnDismissListener) msg.obj).onDismiss(.get());
1048
                    break;
1049
                case :
1050
                    ((OnCancelListener) msg.obj).onCancel(.get());
1051
                    break;
1052
                case :
1053
                    ((OnShowListener) msg.obj).onShow(.get());
1054
                    break;
1055
            }
1056
        }
1057
    }
New to GrepCode? Check out our FAQ X