| Methods Summary |
|---|
| public void | addContentView(android.view.View view, android.view.ViewGroup.LayoutParams params)Add an additional content view to the screen. Added after any existing
ones in the screen -- existing views are NOT removed.
mWindow.addContentView(view, params);
|
| public void | cancel()Cancel the dialog. This is essentially the same as calling {@link #dismiss()}, but it will
also call your {@link DialogInterface.OnCancelListener} (if registered).
if (!mCanceled && mCancelMessage != null) {
mCanceled = true;
// Obtain a new message so this dialog can be re-used
Message.obtain(mCancelMessage).sendToTarget();
}
dismiss();
|
| public void | closeOptionsMenu()
if (mWindow.hasFeature(Window.FEATURE_OPTIONS_PANEL)) {
mWindow.closePanel(Window.FEATURE_OPTIONS_PANEL);
}
|
| public void | create()Forces immediate creation of the dialog.
Note that you should not override this method to perform dialog creation.
Rather, override {@link #onCreate(Bundle)}.
if (!mCreated) {
dispatchOnCreate(null);
}
|
| public void | dismiss()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 {@link #onStop}.
if (Looper.myLooper() == mHandler.getLooper()) {
dismissDialog();
} else {
mHandler.post(mDismissAction);
}
|
| void | dismissDialog()
if (mDecor == null || !mShowing) {
return;
}
if (mWindow.isDestroyed()) {
Log.e(TAG, "Tried to dismissDialog() but the Dialog's window was already destroyed!");
return;
}
try {
mWindowManager.removeViewImmediate(mDecor);
} finally {
if (mActionMode != null) {
mActionMode.finish();
}
mDecor = null;
mWindow.closeAllPanels();
onStop();
mShowing = false;
sendDismissMessage();
}
|
| public boolean | dispatchGenericMotionEvent(android.view.MotionEvent ev)Called to process generic motion events. You can override this to
intercept all generic motion events before they are dispatched to the
window. Be sure to call this implementation for generic motion events
that should be handled normally.
if (mWindow.superDispatchGenericMotionEvent(ev)) {
return true;
}
return onGenericMotionEvent(ev);
|
| public boolean | dispatchKeyEvent(android.view.KeyEvent event)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.
if ((mOnKeyListener != null) && (mOnKeyListener.onKey(this, event.getKeyCode(), event))) {
return true;
}
if (mWindow.superDispatchKeyEvent(event)) {
return true;
}
return event.dispatch(this, mDecor != null
? mDecor.getKeyDispatcherState() : null, this);
|
| public boolean | dispatchKeyShortcutEvent(android.view.KeyEvent event)Called to process a key shortcut event.
You can override this to intercept all key shortcut events before they are
dispatched to the window. Be sure to call this implementation for key shortcut
events that should be handled normally.
if (mWindow.superDispatchKeyShortcutEvent(event)) {
return true;
}
return onKeyShortcut(event.getKeyCode(), event);
|
| void | dispatchOnCreate(android.os.Bundle savedInstanceState)
if (!mCreated) {
onCreate(savedInstanceState);
mCreated = true;
}
|
| public boolean | dispatchPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent event)
event.setClassName(getClass().getName());
event.setPackageName(mContext.getPackageName());
LayoutParams params = getWindow().getAttributes();
boolean isFullScreen = (params.width == LayoutParams.MATCH_PARENT) &&
(params.height == LayoutParams.MATCH_PARENT);
event.setFullScreen(isFullScreen);
return false;
|
| public boolean | dispatchTouchEvent(android.view.MotionEvent ev)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.
if (mWindow.superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
|
| public boolean | dispatchTrackballEvent(android.view.MotionEvent ev)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.
if (mWindow.superDispatchTrackballEvent(ev)) {
return true;
}
return onTrackballEvent(ev);
|
| public android.view.View | findViewById(int id)Finds a child view with the given identifier. Returns null if the
specified child view does not exist or the dialog has not yet been fully
created (for example, via {@link #show()} or {@link #create()}).
return mWindow.findViewById(id);
|
| public ActionBar | getActionBar()Retrieve the {@link ActionBar} attached to this dialog, if present.
return mActionBar;
|
| private android.content.ComponentName | getAssociatedActivity()
Activity activity = mOwnerActivity;
Context context = getContext();
while (activity == null && context != null) {
if (context instanceof Activity) {
activity = (Activity) context; // found it!
} else {
context = (context instanceof ContextWrapper) ?
((ContextWrapper) context).getBaseContext() : // unwrap one level
null; // done
}
}
return activity == null ? null : activity.getComponentName();
|
| public final android.content.Context | getContext()Retrieve the Context this Dialog is running in.
return mContext;
|
| public android.view.View | getCurrentFocus()Call {@link android.view.Window#getCurrentFocus} on the
Window if this Activity to return the currently focused view.
return mWindow != null ? mWindow.getCurrentFocus() : null;
|
| public android.view.LayoutInflater | getLayoutInflater()
return getWindow().getLayoutInflater();
|
| public final Activity | getOwnerActivity()Returns the Activity that owns this Dialog. For example, if
{@link 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.
return mOwnerActivity;
|
| public final int | getVolumeControlStream()
return getWindow().getVolumeControlStream();
|
| public android.view.Window | getWindow()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.
return mWindow;
|
| public void | hide()Hide the dialog, but do not dismiss it.
if (mDecor != null) {
mDecor.setVisibility(View.GONE);
}
|
| public void | invalidateOptionsMenu()
if (mWindow.hasFeature(Window.FEATURE_OPTIONS_PANEL)) {
mWindow.invalidatePanelMenu(Window.FEATURE_OPTIONS_PANEL);
}
|
| public boolean | isShowing()
return mShowing;
|
| public void | onActionModeFinished(android.view.ActionMode mode){@inheritDoc}
Note that if you override this method you should always call through
to the superclass implementation by calling super.onActionModeFinished(mode).
if (mode == mActionMode) {
mActionMode = null;
}
|
| public void | onActionModeStarted(android.view.ActionMode mode){@inheritDoc}
Note that if you override this method you should always call through
to the superclass implementation by calling super.onActionModeStarted(mode).
mActionMode = mode;
|
| public void | onAttachedToWindow()
|
| public void | onBackPressed()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.
if (mCancelable) {
cancel();
}
|
| public void | onContentChanged()
|
| public boolean | onContextItemSelected(android.view.MenuItem item)
return false;
|
| public void | onContextMenuClosed(android.view.Menu menu)
|
| protected void | onCreate(android.os.Bundle savedInstanceState)Similar to {@link Activity#onCreate}, you should initialize your dialog
in this method, including calling {@link #setContentView}.
|
| public void | onCreateContextMenu(android.view.ContextMenu menu, android.view.View v, android.view.ContextMenu.ContextMenuInfo menuInfo)
|
| public boolean | onCreateOptionsMenu(android.view.Menu menu)It is usually safe to proxy this call to the owner activity's
{@link Activity#onCreateOptionsMenu(Menu)} if the client desires the same
menu for this Dialog.
return true;
|
| public boolean | onCreatePanelMenu(int featureId, android.view.Menu menu)
if (featureId == Window.FEATURE_OPTIONS_PANEL) {
return onCreateOptionsMenu(menu);
}
return false;
|
| public android.view.View | onCreatePanelView(int featureId)
return null;
|
| public void | onDetachedFromWindow()
|
| public boolean | onGenericMotionEvent(android.view.MotionEvent event)Called when a generic motion event was not handled by any of the
views inside of the dialog.
Generic motion events describe joystick movements, mouse hovers, track pad
touches, scroll wheel movements and other input events. The
{@link MotionEvent#getSource() source} of the motion event specifies
the class of input that was received. Implementations of this method
must examine the bits in the source before processing the event.
The following code example shows how this is done.
Generic motion events with source class
{@link android.view.InputDevice#SOURCE_CLASS_POINTER}
are delivered to the view under the pointer. All other generic motion events are
delivered to the focused view.
See {@link View#onGenericMotionEvent(MotionEvent)} for an example of how to
handle this event.
return false;
|
| public boolean | onKeyDown(int keyCode, android.view.KeyEvent event)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 {@link #onKeyUp}.
if (keyCode == KeyEvent.KEYCODE_BACK) {
event.startTracking();
return true;
}
return false;
|
| public boolean | onKeyLongPress(int keyCode, android.view.KeyEvent event)Default implementation of {@link KeyEvent.Callback#onKeyLongPress(int, KeyEvent)
KeyEvent.Callback.onKeyLongPress()}: always returns false (doesn't handle
the event).
return false;
|
| public boolean | onKeyMultiple(int keyCode, int repeatCount, android.view.KeyEvent event)Default implementation of {@link KeyEvent.Callback#onKeyMultiple(int, int, KeyEvent)
KeyEvent.Callback.onKeyMultiple()}: always returns false (doesn't handle
the event).
return false;
|
| public boolean | onKeyShortcut(int keyCode, android.view.KeyEvent event)Called when a key shortcut event is not handled by any of the views in the Dialog.
Override this method to implement global key shortcuts for the Dialog.
Key shortcuts can also be implemented by setting the
{@link MenuItem#setShortcut(char, char) shortcut} property of menu items.
return false;
|
| public boolean | onKeyUp(int keyCode, android.view.KeyEvent event)A key was released.
The default implementation handles KEYCODE_BACK to close the
dialog.
if (keyCode == KeyEvent.KEYCODE_BACK && event.isTracking()
&& !event.isCanceled()) {
onBackPressed();
return true;
}
return false;
|
| public boolean | onMenuItemSelected(int featureId, android.view.MenuItem item)
return false;
|
| public boolean | onMenuOpened(int featureId, android.view.Menu menu)
if (featureId == Window.FEATURE_ACTION_BAR) {
mActionBar.dispatchMenuVisibilityChanged(true);
}
return true;
|
| public boolean | onOptionsItemSelected(android.view.MenuItem item)
return false;
|
| public void | onOptionsMenuClosed(android.view.Menu menu)
|
| public void | onPanelClosed(int featureId, android.view.Menu menu)
if (featureId == Window.FEATURE_ACTION_BAR) {
mActionBar.dispatchMenuVisibilityChanged(false);
}
|
| public boolean | onPrepareOptionsMenu(android.view.Menu menu)It is usually safe to proxy this call to the owner activity's
{@link Activity#onPrepareOptionsMenu(Menu)} if the client desires the
same menu for this Dialog.
return true;
|
| public boolean | onPreparePanel(int featureId, android.view.View view, android.view.Menu menu)
if (featureId == Window.FEATURE_OPTIONS_PANEL && menu != null) {
boolean goforit = onPrepareOptionsMenu(menu);
return goforit && menu.hasVisibleItems();
}
return true;
|
| public void | onRestoreInstanceState(android.os.Bundle savedInstanceState)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 {@link #onSaveInstanceState()},
so be sure to call through to super when overriding unless you want to
do all restoring of state yourself.
final Bundle dialogHierarchyState = savedInstanceState.getBundle(DIALOG_HIERARCHY_TAG);
if (dialogHierarchyState == null) {
// dialog has never been shown, or onCreated, nothing to restore.
return;
}
dispatchOnCreate(savedInstanceState);
mWindow.restoreHierarchyState(dialogHierarchyState);
if (savedInstanceState.getBoolean(DIALOG_SHOWING_TAG)) {
show();
}
|
| public android.os.Bundle | onSaveInstanceState()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.
Bundle bundle = new Bundle();
bundle.putBoolean(DIALOG_SHOWING_TAG, mShowing);
if (mCreated) {
bundle.putBundle(DIALOG_HIERARCHY_TAG, mWindow.saveHierarchyState());
}
return bundle;
|
| public boolean | onSearchRequested()This hook is called when the user signals the desire to start a search.
final SearchManager searchManager = (SearchManager) mContext
.getSystemService(Context.SEARCH_SERVICE);
// associate search with owner activity
final ComponentName appName = getAssociatedActivity();
if (appName != null && searchManager.getSearchableInfo(appName) != null) {
searchManager.startSearch(null, false, appName, null, false);
dismiss();
return true;
} else {
return false;
}
|
| protected void | onStart()Called when the dialog is starting.
if (mActionBar != null) mActionBar.setShowHideAnimationEnabled(true);
|
| protected void | onStop()Called to tell you that you're stopping.
if (mActionBar != null) mActionBar.setShowHideAnimationEnabled(false);
|
| public boolean | onTouchEvent(android.view.MotionEvent event)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.
if (mCancelable && mShowing && mWindow.shouldCloseOnTouch(mContext, event)) {
cancel();
return true;
}
return false;
|
| public boolean | onTrackballEvent(android.view.MotionEvent event)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.
return false;
|
| public void | onWindowAttributesChanged(WindowManager.LayoutParams params)
if (mDecor != null) {
mWindowManager.updateViewLayout(mDecor, params);
}
|
| public void | onWindowDismissed()
dismiss();
|
| public void | onWindowFocusChanged(boolean hasFocus)
|
| public android.view.ActionMode | onWindowStartingActionMode(ActionMode.Callback callback)
if (mActionBar != null) {
return mActionBar.startActionMode(callback);
}
return null;
|
| public void | openContextMenu(android.view.View view)
view.showContextMenu();
|
| public void | openOptionsMenu()
if (mWindow.hasFeature(Window.FEATURE_OPTIONS_PANEL)) {
mWindow.openPanel(Window.FEATURE_OPTIONS_PANEL, null);
}
|
| public void | registerForContextMenu(android.view.View view)
view.setOnCreateContextMenuListener(this);
|
| public final boolean | requestWindowFeature(int featureId)Enable extended window features. This is a convenience for calling
{@link android.view.Window#requestFeature getWindow().requestFeature()}.
return getWindow().requestFeature(featureId);
|
| private void | sendDismissMessage()
if (mDismissMessage != null) {
// Obtain a new message so this dialog can be re-used
Message.obtain(mDismissMessage).sendToTarget();
}
|
| private void | sendShowMessage()
if (mShowMessage != null) {
// Obtain a new message so this dialog can be re-used
Message.obtain(mShowMessage).sendToTarget();
}
|
| public void | setCancelMessage(android.os.Message msg)Set a message to be sent when the dialog is canceled.
mCancelMessage = msg;
|
| public void | setCancelable(boolean flag)Sets whether this dialog is cancelable with the
{@link KeyEvent#KEYCODE_BACK BACK} key.
mCancelable = flag;
|
| public void | setCanceledOnTouchOutside(boolean cancel)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.
if (cancel && !mCancelable) {
mCancelable = true;
}
mWindow.setCloseOnTouchOutside(cancel);
|
| public void | setContentView(int layoutResID)Set the screen content from a layout resource. The resource will be
inflated, adding all top-level views to the screen.
mWindow.setContentView(layoutResID);
|
| public void | setContentView(android.view.View view)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 hierarchy.
mWindow.setContentView(view);
|
| public void | setContentView(android.view.View view, android.view.ViewGroup.LayoutParams params)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.
mWindow.setContentView(view, params);
|
| public void | setDismissMessage(android.os.Message msg)Set a message to be sent when the dialog is dismissed.
mDismissMessage = msg;
|
| public final void | setFeatureDrawable(int featureId, android.graphics.drawable.Drawable drawable)Convenience for calling
{@link android.view.Window#setFeatureDrawable(int, Drawable)}.
getWindow().setFeatureDrawable(featureId, drawable);
|
| public final void | setFeatureDrawableAlpha(int featureId, int alpha)Convenience for calling
{@link android.view.Window#setFeatureDrawableAlpha}.
getWindow().setFeatureDrawableAlpha(featureId, alpha);
|
| public final void | setFeatureDrawableResource(int featureId, int resId)Convenience for calling
{@link android.view.Window#setFeatureDrawableResource}.
getWindow().setFeatureDrawableResource(featureId, resId);
|
| public final void | setFeatureDrawableUri(int featureId, android.net.Uri uri)Convenience for calling
{@link android.view.Window#setFeatureDrawableUri}.
getWindow().setFeatureDrawableUri(featureId, uri);
|
| public void | setOnCancelListener(OnCancelListener listener)Set a listener to be invoked when the dialog is canceled.
This will only be invoked when the dialog is canceled.
Cancel events alone will not capture all ways that
the dialog might be dismissed. If the creator needs
to know when a dialog is dismissed in general, use
{@link #setOnDismissListener}.
if (mCancelAndDismissTaken != null) {
throw new IllegalStateException(
"OnCancelListener is already taken by "
+ mCancelAndDismissTaken + " and can not be replaced.");
}
if (listener != null) {
mCancelMessage = mListenersHandler.obtainMessage(CANCEL, listener);
} else {
mCancelMessage = null;
}
|
| public void | setOnDismissListener(OnDismissListener listener)Set a listener to be invoked when the dialog is dismissed.
if (mCancelAndDismissTaken != null) {
throw new IllegalStateException(
"OnDismissListener is already taken by "
+ mCancelAndDismissTaken + " and can not be replaced.");
}
if (listener != null) {
mDismissMessage = mListenersHandler.obtainMessage(DISMISS, listener);
} else {
mDismissMessage = null;
}
|
| public void | setOnKeyListener(OnKeyListener onKeyListener)Sets the callback that will be called if a key is dispatched to the dialog.
mOnKeyListener = onKeyListener;
|
| public void | setOnShowListener(OnShowListener listener)Sets a listener to be invoked when the dialog is shown.
if (listener != null) {
mShowMessage = mListenersHandler.obtainMessage(SHOW, listener);
} else {
mShowMessage = null;
}
|
| public final void | setOwnerActivity(Activity activity)Sets the Activity that owns this dialog. An example use: This Dialog will
use the suggested volume control stream of the Activity.
mOwnerActivity = activity;
getWindow().setVolumeControlStream(mOwnerActivity.getVolumeControlStream());
|
| public void | setTitle(java.lang.CharSequence title)Set the title text for this dialog's window.
mWindow.setTitle(title);
mWindow.getAttributes().setTitle(title);
|
| public void | setTitle(int titleId)Set the title text for this dialog's window. The text is retrieved
from the resources with the supplied identifier.
setTitle(mContext.getText(titleId));
|
| public final void | setVolumeControlStream(int streamType)By default, this will use the owner Activity's suggested stream type.
getWindow().setVolumeControlStream(streamType);
|
| public void | show()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 {@link #onStart}.
if (mShowing) {
if (mDecor != null) {
if (mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
mWindow.invalidatePanelMenu(Window.FEATURE_ACTION_BAR);
}
mDecor.setVisibility(View.VISIBLE);
}
return;
}
mCanceled = false;
if (!mCreated) {
dispatchOnCreate(null);
}
onStart();
mDecor = mWindow.getDecorView();
if (mActionBar == null && mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
final ApplicationInfo info = mContext.getApplicationInfo();
mWindow.setDefaultIcon(info.icon);
mWindow.setDefaultLogo(info.logo);
mActionBar = new WindowDecorActionBar(this);
}
WindowManager.LayoutParams l = mWindow.getAttributes();
if ((l.softInputMode
& WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) == 0) {
WindowManager.LayoutParams nl = new WindowManager.LayoutParams();
nl.copyFrom(l);
nl.softInputMode |=
WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
l = nl;
}
try {
mWindowManager.addView(mDecor, l);
mShowing = true;
sendShowMessage();
} finally {
}
|
| public boolean | takeCancelAndDismissListeners(java.lang.String msg, OnCancelListener cancel, OnDismissListener dismiss)
if (mCancelAndDismissTaken != null) {
mCancelAndDismissTaken = null;
} else if (mCancelMessage != null || mDismissMessage != null) {
return false;
}
setOnCancelListener(cancel);
setOnDismissListener(dismiss);
mCancelAndDismissTaken = msg;
return true;
|
| public void | takeKeyEvents(boolean get)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.
mWindow.takeKeyEvents(get);
|
| public void | unregisterForContextMenu(android.view.View view)
view.setOnCreateContextMenuListener(null);
|
