Dialog

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

Create a Dialog window that uses a custom dialog style.

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

Cancel the dialog. This is essentially the same as calling dismiss(), but it will also call your DialogInterface.OnCancelListener (if registered).

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().

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.

Called to process population of AccessibilityEvents.

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.

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.

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

Retrieve the Context this Dialog is running in.

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

Returns the Activity that owns this Dialog. For example, if 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.

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.

Hide the dialog, but do not dismiss it.

Called when the window has been attached to the window manager. See View.onAttachedToWindow() for more information.

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.

This hook is called whenever the content view of the screen changes (due to a call to Window.setContentView or Window.addContentView).

Called when the context menu for this view is being built. It is not safe to hold onto the menu after this method returns.

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

Initialize the contents of the menu for panel 'featureId'. This is called if onCreatePanelView() returns null, giving you a standard menu in which you can place your items. It is only called once for the panel, the first time it is shown.

You can safely hold on to menu (and any items created from it), making modifications to it as desired, until the next time onCreatePanelMenu() is called for this feature.

Instantiate the view to display in the panel for 'featureId'. You can return null, in which case the default content (typically a menu) will be created for you.

Called when the window has been attached to the window manager. See View.onDetachedFromWindow() for more information.

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, KeyEvent).

Default implementation of KeyEvent.Callback.onKeyLongPress(): always returns false (doesn't handle the event).

Default implementation of KeyEvent.Callback.onKeyMultiple(): always returns false (doesn't handle the event).

A key was released.

The default implementation handles KEYCODE_BACK to close the dialog.

Called when a panel's menu item has been selected by the user.

Called when a panel's menu is opened by the user. This may also be called when the menu is changing from one type to another (for example, from the icon menu to the expanded menu).

Called when a panel is being closed. If another logical subsequent panel is being opened (and this panel is being closed to make room for the subsequent panel), this method will NOT be called.

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

Prepare a panel to be displayed. This is called right before the panel window is shown, every time it is shown.

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.

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.

This hook is called when the user signals the desire to start a search.

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.

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.

This is called whenever the current window attributes change.

This hook is called whenever the window focus changes. See View.onWindowFocusChanged(boolean) for more information.

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

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

Sets whether this dialog is cancelable with the BACK key.

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.

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.

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.

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

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

Convenience for calling setFeatureDrawable(int, Drawable).

Convenience for calling setFeatureDrawableAlpha(int, int).

Convenience for calling setFeatureDrawableResource(int, int).

Convenience for calling setFeatureDrawableUri(int, Uri).

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(DialogInterface.OnDismissListener).

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

Sets the callback that will be called if a key is dispatched to the dialog.

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

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

Set the title text for this dialog's window.

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

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().

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.

Similar to onCreate(Bundle), you should initialized your dialog in this method, including calling setContentView(View).

Called when the dialog is starting.

Called to tell you that you're stopping.