| /* |
| * Copyright (C) 2006 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.app; |
| |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.graphics.drawable.Drawable; |
| import android.net.Uri; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.Bundle; |
| import android.util.Config; |
| import android.util.Log; |
| import android.view.ContextMenu; |
| import android.view.ContextThemeWrapper; |
| import android.view.Gravity; |
| import android.view.KeyEvent; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewConfiguration; |
| import android.view.ViewGroup; |
| import android.view.LayoutInflater; |
| import android.view.Window; |
| import android.view.WindowManager; |
| import android.view.ContextMenu.ContextMenuInfo; |
| import android.view.View.OnCreateContextMenuListener; |
| |
| import com.android.internal.policy.PolicyManager; |
| |
| import java.lang.ref.WeakReference; |
| |
| /** |
| * Base class for Dialogs. |
| * |
| * <p>Note: Activities provide a facility to manage the creation, saving and |
| * restoring of dialogs. See {@link Activity#onCreateDialog(int)}, |
| * {@link Activity#onPrepareDialog(int, Dialog)}, |
| * {@link Activity#showDialog(int)}, and {@link Activity#dismissDialog(int)}. If |
| * these methods are used, {@link #getOwnerActivity()} will return the Activity |
| * that managed this dialog. |
| * |
| * <p>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 {@link WindowManager.LayoutParams#FLAG_ALT_FOCUSABLE_IM |
| * WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM} window flag (assuming |
| * your Dialog takes input focus, as it the default) with the following code: |
| * |
| * <pre> |
| * getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, |
| * WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); |
| * </pre> |
| */ |
| public class Dialog implements DialogInterface, Window.Callback, |
| KeyEvent.Callback, OnCreateContextMenuListener { |
| private static final String LOG_TAG = "Dialog"; |
| |
| private Activity mOwnerActivity; |
| |
| final Context mContext; |
| final WindowManager mWindowManager; |
| Window mWindow; |
| View mDecor; |
| /** |
| * This field should be made private, so it is hidden from the SDK. |
| * {@hide} |
| */ |
| protected boolean mCancelable = true; |
| private Message mCancelMessage; |
| private Message mDismissMessage; |
| |
| /** |
| * Whether to cancel the dialog when a touch is received outside of the |
| * window's bounds. |
| */ |
| private boolean mCanceledOnTouchOutside = false; |
| |
| private OnKeyListener mOnKeyListener; |
| |
| private boolean mCreated = false; |
| private boolean mShowing = false; |
| |
| private final Thread mUiThread; |
| private final Handler mHandler = new Handler(); |
| |
| private final Runnable mDismissAction = new Runnable() { |
| public void run() { |
| dismissDialog(); |
| } |
| }; |
| |
| /** |
| * Create a Dialog window that uses the default dialog frame style. |
| * |
| * @param 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. |
| */ |
| public Dialog(Context context) { |
| this(context, 0); |
| } |
| |
| /** |
| * Create a Dialog window that uses a custom dialog style. |
| * |
| * @param 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. |
| * @param theme A style resource describing the theme to use for the |
| * window. See <a href="{@docRoot}reference/available-resources.html#stylesandthemes">Style |
| * and Theme Resources</a> for more information about defining and using |
| * styles. This theme is applied on top of the current theme in |
| * <var>context</var>. If 0, the default dialog theme will be used. |
| */ |
| public Dialog(Context context, int theme) { |
| mContext = new ContextThemeWrapper( |
| context, theme == 0 ? com.android.internal.R.style.Theme_Dialog : theme); |
| mWindowManager = (WindowManager)context.getSystemService("window"); |
| Window w = PolicyManager.makeNewWindow(mContext); |
| mWindow = w; |
| w.setCallback(this); |
| w.setWindowManager(mWindowManager, null, null); |
| w.setGravity(Gravity.CENTER); |
| mUiThread = Thread.currentThread(); |
| mDismissCancelHandler = new DismissCancelHandler(this); |
| } |
| |
| /** |
| * @deprecated |
| * @hide |
| */ |
| @Deprecated |
| protected Dialog(Context context, boolean cancelable, |
| Message cancelCallback) { |
| this(context); |
| mCancelable = cancelable; |
| mCancelMessage = cancelCallback; |
| } |
| |
| protected Dialog(Context context, boolean cancelable, |
| OnCancelListener cancelListener) { |
| this(context); |
| mCancelable = cancelable; |
| setOnCancelListener(cancelListener); |
| } |
| |
| /** |
| * Retrieve the Context this Dialog is running in. |
| * |
| * @return Context The Context that was supplied to the constructor. |
| */ |
| public final Context getContext() { |
| return mContext; |
| } |
| |
| /** |
| * Sets the Activity that owns this dialog. An example use: This Dialog will |
| * use the suggested volume control stream of the Activity. |
| * |
| * @param activity The Activity that owns this dialog. |
| */ |
| public final void setOwnerActivity(Activity activity) { |
| mOwnerActivity = activity; |
| |
| getWindow().setVolumeControlStream(mOwnerActivity.getVolumeControlStream()); |
| } |
| |
| /** |
| * 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 The Activity that owns this Dialog. |
| */ |
| public final Activity getOwnerActivity() { |
| return mOwnerActivity; |
| } |
| |
| /** |
| * @return Whether the dialog is currently showing. |
| */ |
| public boolean isShowing() { |
| return mShowing; |
| } |
| |
| /** |
| * 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}. |
| */ |
| public void show() { |
| if (mShowing) { |
| if (Config.LOGV) Log.v(LOG_TAG, |
| "[Dialog] start: already showing, ignore"); |
| if (mDecor != null) mDecor.setVisibility(View.VISIBLE); |
| return; |
| } |
| |
| if (!mCreated) { |
| dispatchOnCreate(null); |
| } |
| |
| onStart(); |
| mDecor = mWindow.getDecorView(); |
| 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; |
| } |
| mWindowManager.addView(mDecor, l); |
| mShowing = true; |
| } |
| |
| /** |
| * Hide the dialog, but do not dismiss it. |
| */ |
| public void hide() { |
| if (mDecor != null) mDecor.setVisibility(View.GONE); |
| } |
| |
| /** |
| * 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}. |
| */ |
| public void dismiss() { |
| if (Thread.currentThread() != mUiThread) { |
| mHandler.post(mDismissAction); |
| } else { |
| mDismissAction.run(); |
| } |
| } |
| |
| private void dismissDialog() { |
| if (mDecor == null) { |
| if (Config.LOGV) Log.v(LOG_TAG, |
| "[Dialog] dismiss: already dismissed, ignore"); |
| return; |
| } |
| if (!mShowing) { |
| if (Config.LOGV) Log.v(LOG_TAG, |
| "[Dialog] dismiss: not showing, ignore"); |
| return; |
| } |
| |
| mWindowManager.removeView(mDecor); |
| mDecor = null; |
| mWindow.closeAllPanels(); |
| onStop(); |
| mShowing = false; |
| |
| sendDismissMessage(); |
| } |
| |
| private void sendDismissMessage() { |
| if (mDismissMessage != null) { |
| // Obtain a new message so this dialog can be re-used |
| Message.obtain(mDismissMessage).sendToTarget(); |
| } |
| } |
| |
| // internal method to make sure mcreated is set properly without requiring |
| // users to call through to super in onCreate |
| void dispatchOnCreate(Bundle savedInstanceState) { |
| onCreate(savedInstanceState); |
| mCreated = true; |
| } |
| |
| /** |
| * Similar to {@link Activity#onCreate}, you should initialized your dialog |
| * in this method, including calling {@link #setContentView}. |
| * @param 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 {@link #onSaveInstanceState}, or null if this |
| * is the first time. |
| */ |
| protected void onCreate(Bundle savedInstanceState) { |
| } |
| |
| /** |
| * Called when the dialog is starting. |
| */ |
| protected void onStart() { |
| } |
| |
| /** |
| * Called to tell you that you're stopping. |
| */ |
| protected void onStop() { |
| } |
| |
| private static final String DIALOG_SHOWING_TAG = "android:dialogShowing"; |
| 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. |
| * @return A bundle with the state of the dialog. |
| */ |
| public Bundle onSaveInstanceState() { |
| Bundle bundle = new Bundle(); |
| bundle.putBoolean(DIALOG_SHOWING_TAG, mShowing); |
| if (mCreated) { |
| bundle.putBundle(DIALOG_HIERARCHY_TAG, mWindow.saveHierarchyState()); |
| } |
| return bundle; |
| } |
| |
| /** |
| * 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. |
| * @param savedInstanceState The state of the dialog previously saved by |
| * {@link #onSaveInstanceState()}. |
| */ |
| public void onRestoreInstanceState(Bundle savedInstanceState) { |
| 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(); |
| } |
| } |
| |
| /** |
| * 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 Window The current window, or null if the activity is not |
| * visual. |
| */ |
| public Window getWindow() { |
| return mWindow; |
| } |
| |
| /** |
| * Call {@link android.view.Window#getCurrentFocus} on the |
| * Window if this Activity to return the currently focused view. |
| * |
| * @return View The current View with focus or null. |
| * |
| * @see #getWindow |
| * @see android.view.Window#getCurrentFocus |
| */ |
| public View getCurrentFocus() { |
| return mWindow != null ? mWindow.getCurrentFocus() : null; |
| } |
| |
| /** |
| * Finds a view that was identified by the id attribute from the XML that |
| * was processed in {@link #onStart}. |
| * |
| * @param id the identifier of the view to find |
| * @return The view if found or null otherwise. |
| */ |
| public View findViewById(int id) { |
| return mWindow.findViewById(id); |
| } |
| |
| /** |
| * Set the screen content from a layout resource. The resource will be |
| * inflated, adding all top-level views to the screen. |
| * |
| * @param layoutResID Resource ID to be inflated. |
| */ |
| public void setContentView(int layoutResID) { |
| mWindow.setContentView(layoutResID); |
| } |
| |
| /** |
| * 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. |
| * |
| * @param view The desired content to display. |
| */ |
| public void setContentView(View view) { |
| mWindow.setContentView(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 hierarhcy. |
| * |
| * @param view The desired content to display. |
| * @param params Layout parameters for the view. |
| */ |
| public void setContentView(View view, ViewGroup.LayoutParams params) { |
| mWindow.setContentView(view, params); |
| } |
| |
| /** |
| * Add an additional content view to the screen. Added after any existing |
| * ones in the screen -- existing views are NOT removed. |
| * |
| * @param view The desired content to display. |
| * @param params Layout parameters for the view. |
| */ |
| public void addContentView(View view, ViewGroup.LayoutParams params) { |
| mWindow.addContentView(view, params); |
| } |
| |
| /** |
| * Set the title text for this dialog's window. |
| * |
| * @param title The new text to display in the title. |
| */ |
| public void setTitle(CharSequence title) { |
| mWindow.setTitle(title); |
| mWindow.getAttributes().setTitle(title); |
| } |
| |
| /** |
| * Set the title text for this dialog's window. The text is retrieved |
| * from the resources with the supplied identifier. |
| * |
| * @param titleId the title's text resource identifier |
| */ |
| public void setTitle(int titleId) { |
| setTitle(mContext.getText(titleId)); |
| } |
| |
| /** |
| * A key was pressed down. |
| * |
| * <p>If the focused view didn't want this event, this method is called. |
| * |
| * <p>The default implementation handles KEYCODE_BACK to close the |
| * dialog. |
| * |
| * @see #onKeyUp |
| * @see android.view.KeyEvent |
| */ |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| if (keyCode == KeyEvent.KEYCODE_BACK) { |
| if (mCancelable) { |
| cancel(); |
| } |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * A key was released. |
| * |
| * @see #onKeyDown |
| * @see KeyEvent |
| */ |
| public boolean onKeyUp(int keyCode, KeyEvent event) { |
| return false; |
| } |
| |
| /** |
| * Default implementation of {@link KeyEvent.Callback#onKeyMultiple(int, int, KeyEvent) |
| * KeyEvent.Callback.onKeyMultiple()}: always returns false (doesn't handle |
| * the event). |
| */ |
| public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) { |
| return false; |
| } |
| |
| /** |
| * 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. |
| * |
| * @param event The touch screen event being processed. |
| * @return 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. |
| */ |
| public boolean onTouchEvent(MotionEvent event) { |
| if (mCancelable && mCanceledOnTouchOutside && event.getAction() == MotionEvent.ACTION_DOWN |
| && isOutOfBounds(event)) { |
| cancel(); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| private boolean isOutOfBounds(MotionEvent event) { |
| final int x = (int) event.getX(); |
| final int y = (int) event.getY(); |
| final int slop = ViewConfiguration.getWindowTouchSlop(); |
| final View decorView = getWindow().getDecorView(); |
| return (x < -slop) || (y < -slop) |
| || (x > (decorView.getWidth()+slop)) |
| || (y > (decorView.getHeight()+slop)); |
| } |
| |
| /** |
| * 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 <em>before</em> 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. |
| * |
| * @param event The trackball event being processed. |
| * |
| * @return Return true if you have consumed the event, false if you haven't. |
| * The default implementation always returns false. |
| */ |
| public boolean onTrackballEvent(MotionEvent event) { |
| return false; |
| } |
| |
| public void onWindowAttributesChanged(WindowManager.LayoutParams params) { |
| if (mDecor != null) { |
| mWindowManager.updateViewLayout(mDecor, params); |
| } |
| } |
| |
| public void onContentChanged() { |
| } |
| |
| public void onWindowFocusChanged(boolean hasFocus) { |
| } |
| |
| /** |
| * 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. |
| * |
| * @param event The key event. |
| * |
| * @return boolean Return true if this event was consumed. |
| */ |
| public boolean dispatchKeyEvent(KeyEvent event) { |
| if ((mOnKeyListener != null) && (mOnKeyListener.onKey(this, event.getKeyCode(), event))) { |
| return true; |
| } |
| if (mWindow.superDispatchKeyEvent(event)) { |
| return true; |
| } |
| return event.dispatch(this); |
| } |
| |
| /** |
| * 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. |
| * |
| * @param ev The touch screen event. |
| * |
| * @return boolean Return true if this event was consumed. |
| */ |
| public boolean dispatchTouchEvent(MotionEvent ev) { |
| if (mWindow.superDispatchTouchEvent(ev)) { |
| return true; |
| } |
| return onTouchEvent(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. |
| * |
| * @param ev The trackball event. |
| * |
| * @return boolean Return true if this event was consumed. |
| */ |
| public boolean dispatchTrackballEvent(MotionEvent ev) { |
| if (mWindow.superDispatchTrackballEvent(ev)) { |
| return true; |
| } |
| return onTrackballEvent(ev); |
| } |
| |
| /** |
| * @see Activity#onCreatePanelView(int) |
| */ |
| public View onCreatePanelView(int featureId) { |
| return null; |
| } |
| |
| /** |
| * @see Activity#onCreatePanelMenu(int, Menu) |
| */ |
| public boolean onCreatePanelMenu(int featureId, Menu menu) { |
| if (featureId == Window.FEATURE_OPTIONS_PANEL) { |
| return onCreateOptionsMenu(menu); |
| } |
| |
| return false; |
| } |
| |
| /** |
| * @see Activity#onPreparePanel(int, View, Menu) |
| */ |
| public boolean onPreparePanel(int featureId, View view, Menu menu) { |
| if (featureId == Window.FEATURE_OPTIONS_PANEL && menu != null) { |
| boolean goforit = onPrepareOptionsMenu(menu); |
| return goforit && menu.hasVisibleItems(); |
| } |
| return true; |
| } |
| |
| /** |
| * @see Activity#onMenuOpened(int, Menu) |
| */ |
| public boolean onMenuOpened(int featureId, Menu menu) { |
| return true; |
| } |
| |
| /** |
| * @see Activity#onMenuItemSelected(int, MenuItem) |
| */ |
| public boolean onMenuItemSelected(int featureId, MenuItem item) { |
| return false; |
| } |
| |
| /** |
| * @see Activity#onPanelClosed(int, Menu) |
| */ |
| public void onPanelClosed(int featureId, 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. |
| * |
| * @see Activity#onCreateOptionsMenu(Menu) |
| * @see #getOwnerActivity() |
| */ |
| public boolean onCreateOptionsMenu(Menu menu) { |
| return true; |
| } |
| |
| /** |
| * 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. |
| * |
| * @see Activity#onPrepareOptionsMenu(Menu) |
| * @see #getOwnerActivity() |
| */ |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| return true; |
| } |
| |
| /** |
| * @see Activity#onOptionsItemSelected(MenuItem) |
| */ |
| public boolean onOptionsItemSelected(MenuItem item) { |
| return false; |
| } |
| |
| /** |
| * @see Activity#onOptionsMenuClosed(Menu) |
| */ |
| public void onOptionsMenuClosed(Menu menu) { |
| } |
| |
| /** |
| * @see Activity#openOptionsMenu() |
| */ |
| public void openOptionsMenu() { |
| mWindow.openPanel(Window.FEATURE_OPTIONS_PANEL, null); |
| } |
| |
| /** |
| * @see Activity#closeOptionsMenu() |
| */ |
| public void closeOptionsMenu() { |
| mWindow.closePanel(Window.FEATURE_OPTIONS_PANEL); |
| } |
| |
| /** |
| * @see Activity#onCreateContextMenu(ContextMenu, View, ContextMenuInfo) |
| */ |
| public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) { |
| } |
| |
| /** |
| * @see Activity#registerForContextMenu(View) |
| */ |
| public void registerForContextMenu(View view) { |
| view.setOnCreateContextMenuListener(this); |
| } |
| |
| /** |
| * @see Activity#unregisterForContextMenu(View) |
| */ |
| public void unregisterForContextMenu(View view) { |
| view.setOnCreateContextMenuListener(null); |
| } |
| |
| /** |
| * @see Activity#openContextMenu(View) |
| */ |
| public void openContextMenu(View view) { |
| view.showContextMenu(); |
| } |
| |
| /** |
| * @see Activity#onContextItemSelected(MenuItem) |
| */ |
| public boolean onContextItemSelected(MenuItem item) { |
| return false; |
| } |
| |
| /** |
| * @see Activity#onContextMenuClosed(Menu) |
| */ |
| public void onContextMenuClosed(Menu menu) { |
| } |
| |
| /** |
| * This hook is called when the user signals the desire to start a search. |
| */ |
| public boolean onSearchRequested() { |
| // not during dialogs, no. |
| return false; |
| } |
| |
| |
| /** |
| * 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. |
| * |
| * @param get true if the dialog should receive key events, false otherwise |
| * @see android.view.Window#takeKeyEvents |
| */ |
| public void takeKeyEvents(boolean get) { |
| mWindow.takeKeyEvents(get); |
| } |
| |
| /** |
| * Enable extended window features. This is a convenience for calling |
| * {@link android.view.Window#requestFeature getWindow().requestFeature()}. |
| * |
| * @param featureId The desired feature as defined in |
| * {@link android.view.Window}. |
| * @return Returns true if the requested feature is supported and now |
| * enabled. |
| * |
| * @see android.view.Window#requestFeature |
| */ |
| public final boolean requestWindowFeature(int featureId) { |
| return getWindow().requestFeature(featureId); |
| } |
| |
| /** |
| * Convenience for calling |
| * {@link android.view.Window#setFeatureDrawableResource}. |
| */ |
| public final void setFeatureDrawableResource(int featureId, int resId) { |
| getWindow().setFeatureDrawableResource(featureId, resId); |
| } |
| |
| /** |
| * Convenience for calling |
| * {@link android.view.Window#setFeatureDrawableUri}. |
| */ |
| public final void setFeatureDrawableUri(int featureId, Uri uri) { |
| getWindow().setFeatureDrawableUri(featureId, uri); |
| } |
| |
| /** |
| * Convenience for calling |
| * {@link android.view.Window#setFeatureDrawable(int, Drawable)}. |
| */ |
| public final void setFeatureDrawable(int featureId, Drawable drawable) { |
| getWindow().setFeatureDrawable(featureId, drawable); |
| } |
| |
| /** |
| * Convenience for calling |
| * {@link android.view.Window#setFeatureDrawableAlpha}. |
| */ |
| public final void setFeatureDrawableAlpha(int featureId, int alpha) { |
| getWindow().setFeatureDrawableAlpha(featureId, alpha); |
| } |
| |
| public LayoutInflater getLayoutInflater() { |
| return getWindow().getLayoutInflater(); |
| } |
| |
| /** |
| * Sets whether this dialog is cancelable with the |
| * {@link KeyEvent#KEYCODE_BACK BACK} key. |
| */ |
| public void setCancelable(boolean flag) { |
| mCancelable = flag; |
| } |
| |
| /** |
| * 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. |
| * |
| * @param cancel Whether the dialog should be canceled when touched outside |
| * the window. |
| */ |
| public void setCanceledOnTouchOutside(boolean cancel) { |
| if (cancel && !mCancelable) { |
| mCancelable = true; |
| } |
| |
| mCanceledOnTouchOutside = cancel; |
| } |
| |
| /** |
| * Cancel the dialog. This is essentially the same as calling {@link #dismiss()}, but it will |
| * also call your {@link DialogInterface.OnCancelListener} (if registered). |
| */ |
| public void cancel() { |
| if (mCancelMessage != null) { |
| |
| // Obtain a new message so this dialog can be re-used |
| Message.obtain(mCancelMessage).sendToTarget(); |
| } |
| dismiss(); |
| } |
| |
| /** |
| * Set a listener to be invoked when the dialog is canceled. |
| * <p> |
| * This will only be invoked when the dialog is canceled, if the creator |
| * needs to know when it is dismissed in general, use |
| * {@link #setOnDismissListener}. |
| * |
| * @param listener The {@link DialogInterface.OnCancelListener} to use. |
| */ |
| public void setOnCancelListener(final OnCancelListener listener) { |
| if (listener != null) { |
| mCancelMessage = mDismissCancelHandler.obtainMessage(CANCEL, listener); |
| } else { |
| mCancelMessage = null; |
| } |
| } |
| |
| /** |
| * Set a message to be sent when the dialog is canceled. |
| * @param msg The msg to send when the dialog is canceled. |
| * @see #setOnCancelListener(android.content.DialogInterface.OnCancelListener) |
| */ |
| public void setCancelMessage(final Message msg) { |
| mCancelMessage = msg; |
| } |
| |
| /** |
| * Set a listener to be invoked when the dialog is dismissed. |
| * @param listener The {@link DialogInterface.OnDismissListener} to use. |
| */ |
| public void setOnDismissListener(final OnDismissListener listener) { |
| if (listener != null) { |
| mDismissMessage = mDismissCancelHandler.obtainMessage(DISMISS, listener); |
| } else { |
| mDismissMessage = null; |
| } |
| } |
| |
| /** |
| * Set a message to be sent when the dialog is dismissed. |
| * @param msg The msg to send when the dialog is dismissed. |
| */ |
| public void setDismissMessage(final Message msg) { |
| mDismissMessage = msg; |
| } |
| |
| /** |
| * By default, this will use the owner Activity's suggested stream type. |
| * |
| * @see Activity#setVolumeControlStream(int) |
| * @see #setOwnerActivity(Activity) |
| */ |
| public final void setVolumeControlStream(int streamType) { |
| getWindow().setVolumeControlStream(streamType); |
| } |
| |
| /** |
| * @see Activity#getVolumeControlStream() |
| */ |
| public final int getVolumeControlStream() { |
| return getWindow().getVolumeControlStream(); |
| } |
| |
| /** |
| * Sets the callback that will be called if a key is dispatched to the dialog. |
| */ |
| public void setOnKeyListener(final OnKeyListener onKeyListener) { |
| mOnKeyListener = onKeyListener; |
| } |
| |
| private static final int DISMISS = 0x43; |
| private static final int CANCEL = 0x44; |
| |
| private Handler mDismissCancelHandler; |
| |
| private static final class DismissCancelHandler extends Handler { |
| private WeakReference<DialogInterface> mDialog; |
| |
| public DismissCancelHandler(Dialog dialog) { |
| mDialog = new WeakReference<DialogInterface>(dialog); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case DISMISS: |
| ((OnDismissListener) msg.obj).onDismiss(mDialog.get()); |
| break; |
| case CANCEL: |
| ((OnCancelListener) msg.obj).onCancel(mDialog.get()); |
| break; |
| } |
| } |
| } |
| } |
