android拨号的输入框
[问题点数：30分，无满意结帖，结帖人wangtuwen]
android拨号的输入框
[问题点数：30分，无满意结帖，结帖人wangtuwen]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
相关帖子推荐：
本帖子已过去太久远了，不再提供回复功能。8369人阅读
& &在学习设计模式时，发现AlertDialog和它的内部类Builder就是比较典型的，所以先分析下基类Dialog，然后再看子类和它的内部类。 按照惯例，先看下类说明：Base class for Dialogs.
Note: Activities provide a facility to manage the creation, saving and restoring of dialogs. See onCreateDialog(int), onPrepareDialog(int, Dialog), showDialog(int), and 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);Dialog是一系列Dialogs的基类。注意：Activity提供了onCreateDialog(int)、onPrepareDialog(int, Dialog)和showDialog(int)这一些列方法用于管理dialog的创建、保存和恢复（注：关于的用法见于：）。如果使用了以上方法，Dialog的getOwnerActivity方法就会返回创建Dialog的Activity。 如果你的Dialog不需要输入文本，想要显示在当前显示的输入法的上面，可以像下面代码通过设置WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM来实现（如果想要获取输入，则不用设置，默认获取焦点） getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
使用WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM此标志位表示隐藏输入法。 看一下所用到的全局变量：public class Dialog implements DialogInterface, Window.Callback,
KeyEvent.Callback, OnCreateContextMenuListener {
private static final String TAG = &Dialog&;
private Activity mOwnerA
final Context mC
final WindowManager mWindowM
private ActionBarImpl mActionB
* This field should be made private, so it is hidden from the SDK.
protected boolean mCancelable =
private String mCancelAndDismissT
private Message mCancelM
private Message mDismissM
private Message mShowM
private OnKeyListener mOnKeyL
private boolean mCreated =
private boolean mShowing =
private boolean mCanceled =
private final Thread mUiT
private final Handler mHandler = new Handler();
private static final int DISMISS = 0x43;
private static final int CANCEL = 0x44;
private static final int SHOW = 0x45;
private Handler mListenersH
private ActionMode mActionM
private final Runnable mDismissAction = new Runnable() {
public void run() {
dismissDialog();
};变量都比较简单，这里不再详述。 Dialog类实现了DialogInterface, Window.Callback,KeyEvent.Callback, OnCreateContextMenuListener这些接口，今天看下DialogInterface接口，其他接口在Activity源码和Menu源码的时候再看。public interface DialogInterface {
* The identifier for the positive button.
public static final int BUTTON_POSITIVE = -1;
* The identifier for the negative button.
public static final int BUTTON_NEGATIVE = -2;
* The identifier for the neutral button.
public static final int BUTTON_NEUTRAL = -3;
* @deprecated Use {@link #BUTTON_POSITIVE}
@Deprecated
public static final int BUTTON1 = BUTTON_POSITIVE;
* @deprecated Use {@link #BUTTON_NEGATIVE}
@Deprecated
public static final int BUTTON2 = BUTTON_NEGATIVE;
* @deprecated Use {@link #BUTTON_NEUTRAL}
@Deprecated
public static final int BUTTON3 = BUTTON_NEUTRAL;
public void cancel();
public void dismiss();
* Interface used to allow the creator of a dialog to run some code when the
* dialog is canceled.
* This will only be called when the dialog is canceled, if the creator
* needs to know when it is dismissed in general, use
* {@link DialogInterface.OnDismissListener}.
interface OnCancelListener {
* This method will be invoked when the dialog is canceled.
* @param dialog The dialog that was canceled will be passed into the
public void onCancel(DialogInterface dialog);
* Interface used to allow the creator of a dialog to run some code when the
* dialog is dismissed.
interface OnDismissListener {
* This method will be invoked when the dialog is dismissed.
* @param dialog The dialog that was dismissed will be passed into the
public void onDismiss(DialogInterface dialog);
* Interface used to allow the creator of a dialog to run some code when the
* dialog is shown.
interface OnShowListener {
* This method will be invoked when the dialog is shown.
* @param dialog The dialog that was shown will be passed into the
public void onShow(DialogInterface dialog);
* Interface used to allow the creator of a dialog to run some code when an
* item on the dialog is clicked..
interface OnClickListener {
* This method will be invoked when a button in the dialog is clicked.
* @param dialog The dialog that received the click.
* @param which The button that was clicked (e.g.
{@link DialogInterface#BUTTON1}) or the position
of the item clicked.
/* TODO: Change to use BUTTON_POSITIVE after API council */
public void onClick(DialogInterface dialog, int which);
* Interface used to allow the creator of a dialog to run some code when an
* item in a multi-choice dialog is clicked.
interface OnMultiChoiceClickListener {
* This method will be invoked when an item in the dialog is clicked.
* @param dialog The dialog where the selection was made.
* @param which The position of the item in the list that was clicked.
* @param isChecked True if the click checked the item, else false.
public void onClick(DialogInterface dialog, int which, boolean isChecked);
* Interface definition for a callback to be invoked when a key event is
* dispatched to this dialog. The callback will be invoked before the key
* event is given to the dialog.
interface OnKeyListener {
* Called when a key is dispatched to a dialog. This allows listeners to
* get a chance to respond before the dialog.
* @param dialog The dialog the key has been dispatched to.
* @param keyCode The code for the physical key that was pressed
* @param event The KeyEvent object containing full information about
the event.
* @return True if the listener has consumed the event, false otherwise.
public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event);
里面有代表三个button的变量，还有cancel()、dismiss()、还有OnCancelListener、OnDismissListener、OnShowListener、OnClickListener、OnMultiChoiceClickListener、OnKeyListener这些回调接口，会在AlertDialog源码解析中来说明这些方法。 下面是它的构造方法：/**
* 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, true);
* 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}guide/topics/resources/available-resources.html#stylesandthemes&&Style
* and Theme Resources&/a& for more information about defining and using
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) {
this(context, theme, true);
Dialog(Context context, int theme, boolean createContextWrapper) {
if (theme == 0) {
TypedValue outValue = new TypedValue();
context.getTheme().resolveAttribute(com.android.internal.R.attr.dialogTheme,
outValue, true);
theme = outValue.resourceId;
mContext = createContextWrapper ? new ContextThemeWrapper(context, theme) :
mWindowManager = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Window w = PolicyManager.makeNewWindow(mContext);
w.setCallback(this);
w.setWindowManager(mWindowManager, null, null);
w.setGravity(Gravity.CENTER);
mUiThread = Thread.currentThread();
mListenersHandler = new ListenersHandler(this);
* @deprecated
@Deprecated
protected Dialog(Context context, boolean cancelable,
Message cancelCallback) {
this(context);
mCancelable =
mCancelMessage = cancelC
protected Dialog(Context context, boolean cancelable,
OnCancelListener cancelListener) {
this(context);
mCancelable =
setOnCancelListener(cancelListener);
}第一个构造方法是使用对话框风格，第二个构造方法使用自定义的对话框风格，这两个构造方法都是调用的下面的Dialog方法，我们注意到他的权限是缺省，就是我我们在外部不能直接使用该构造方法。Dialog(Context context, int theme, boolean createContextWrapper) {
if (theme == 0) {
TypedValue outValue = new TypedValue();
context.getTheme().resolveAttribute(com.android.internal.R.attr.dialogTheme,
outValue, true);
theme = outValue.resourceId;
mContext = createContextWrapper ? new ContextThemeWrapper(context, theme) :
mWindowManager = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Window w = PolicyManager.makeNewWindow(mContext);
w.setCallback(this);
w.setWindowManager(mWindowManager, null, null);
w.setGravity(Gravity.CENTER);
mUiThread = Thread.currentThread();
mListenersHandler = new ListenersHandler(this);
}如果theme为0，则使用系统定义的风格，然后初始化mWindow。 第三个构造方法被Deprecated掉，不看，第四个可以实现取消回调。 再看下面的两个方法：/**
* Retrieve the Context this Dialog is running in.
* @return Context The Context used by the Dialog.
public final Context getContext() {
* Retrieve the {@link ActionBar} attached to this dialog, if present.
* @return The ActionBar attached to the dialog or null if no ActionBar is present.
public ActionBar getActionBar() {
return mActionB
}获取Dialog运行的山下文环境和ActionBar。/**
* 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 =
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 mOwnerA
}设置和获取Dialog所属的Activity和获取（如果在onCreate（）之外创建dialog，它不会附属于任何的Activity，可以使用dialog的setOwnerActivity(Activity)来设置），调用showDialog方法的Activity默认情况下就是要返回的Activity。
* @return Whether the dialog is currently showing.
public boolean isShowing() {
判断当前Dialog是否显示。/**
* 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 (mDecor != null) {
if (mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
mWindow.invalidatePanelMenu(Window.FEATURE_ACTION_BAR);
mDecor.setVisibility(View.VISIBLE);
mCanceled =
if (!mCreated) {
dispatchOnCreate(null);
onStart();
mDecor = mWindow.getDecorView();
if (mActionBar == null && mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
mActionBar = new ActionBarImpl(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;
mWindowManager.addView(mDecor, l);
mShowing =
sendShowMessage();
} finally {
}显示创建的dialog，它是不透明的并且你不能在它显示的时候重载show方法，可以在onStart方法里实现。当mCreate为false的时候调用了dispatchOnCreate方法同时里面调用onCreate方法确保Dialog被初始化：// internal method to make sure mcreated is set properly without requiring
// users to call through to super in onCreate
void dispatchOnCreate(Bundle savedInstanceState) {
if (!mCreated) {
onCreate(savedInstanceState);
mCreated =
* Similar to {@link Activity#onCreate}, you should initialize 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() {
if (mActionBar != null) mActionBar.setShowHideAnimationEnabled(true);
}一切都创建好以后：调用sendShowMessage方法向UI线程发送一个消息：private void sendShowMessage() {
if (mShowMessage != null) {
// Obtain a new message so this dialog can be re-used
Message.obtain(mShowMessage).sendToTarget();
} 隐藏Dialog（但不是去除Dialog）：/**
* Hide the dialog, but do not dismiss it.
public void hide() {
if (mDecor != null) {
mDecor.setVisibility(View.GONE);
} 去除Dialog：
* 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);
mHandler.removeCallbacks(mDismissAction);
mDismissAction.run();
}从屏幕上去除dialog，这个方法在任何线程中都是安全的，注意当dialog被取消，不要重写这个方法。可以在onStop方法里面调用dismiss方法。 里面执行了mDismissAction这个runnable：private final Runnable mDismissAction = new Runnable() {
public void run() {
dismissDialog();
};&主要执行dismissDialog方法： void dismissDialog() {
if (mDecor == null || !mShowing) {
if (mWindow.isDestroyed()) {
Log.e(TAG, &Tried to dismissDialog() but the Dialog's window was already destroyed!&);
mWindowManager.removeView(mDecor);
} finally {
if (mActionMode != null) {
mActionMode.finish();
mWindow.closeAllPanels();
mShowing =
sendDismissMessage();
}里面主要任务就是销毁一切资源，然后里面调用了onStop方法：
* Called to tell you that you're stopping.
protected void onStop() {
if (mActionBar != null) mActionBar.setShowHideAnimationEnabled(false);
}把ActionBar功能设为false。上面还调用了senDismissMessage方法：private void sendDismissMessage() {
if (mDismissMessage != null) {
// Obtain a new message so this dialog can be re-used
Message.obtain(mDismissMessage).sendToTarget();
}下一个就是保持状态的onSaveInstanceState和从保存状态中恢复onRestoreInstanceState：
* 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
* @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());
* 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.
dispatchOnCreate(savedInstanceState);
mWindow.restoreHierarchyState(dialogHierarchyState);
if (savedInstanceState.getBoolean(DIALOG_SHOWING_TAG)) {
} 下一个方法是获取当前的Window用于直接访问其API而不是通过Activity或者Screen：
* 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
public Window getWindow() {
} 再获取当前拥有焦点的View：
* 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() :
} 还可以在onStart方法里面调用findViewById来通过ID获取xml文件中的View：/**
* 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);
} 也可以通过ID和View设置Dialog的View：
* 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);
} 还可以添加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);
在Dialog已存在的View的基础上，再添加一个View:
* 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);
}先前的View并不会被去除。 为Dialog设置标题：
* 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));
} onKeyDown只处理了back键：/**
* A key was pressed down.
* &p&If the focused view didn't want this event, this method is called.
* &p&The default implementation consumed the KEYCODE_BACK to later
* handle it in {@link #onKeyUp}.
* @see #onKeyUp
* @see android.view.KeyEvent
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
event.startTracking();
长按则不做任何处理：
* Default implementation of {@link KeyEvent.Callback#onKeyLongPress(int, KeyEvent)
* KeyEvent.Callback.onKeyLongPress()}: always returns false (doesn't handle
* the event).
public boolean onKeyLongPress(int keyCode, KeyEvent event) {
}按键松开：
* A key was released.
* &p&The default implementation handles KEYCODE_BACK to close the
* @see #onKeyDown
* @see KeyEvent
public boolean onKeyUp(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK && event.isTracking()
&& !event.isCanceled()) {
onBackPressed();
}还是只处理back键，调用onBackPressed：
* Called when the dialog has detected the user's press of the back
The default implementation simply cancels the dialog (only if
* it is cancelable), but you can override this to do whatever you want.
public void onBackPressed() {
if (mCancelable) {
}这个方法默认实现当你按返回键的时候简单的取消dialog，如果你想实现其他功能，可以重写它。/**
* Called when an 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.
* @param keyCode The value in event.getKeyCode().
* @param event Description of the key event.
* @return True if the key shortcut was handled.
public boolean onKeyShortcut(int keyCode, KeyEvent event) {
对多次重复按键不做任何响应：
* 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) {
}对于快捷键，不做任何处理。/**
* 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 && mShowing && mWindow.shouldCloseOnTouch(mContext, event)) {
}onTouch事件，当发生在dialog区域内，不做任何事，发生在区域外，去除Dialog。/**
* 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 (!mCanceled && mCancelMessage != null) {
mCanceled =
// Obtain a new message so this dialog can be re-used
Message.obtain(mCancelMessage).sendToTarget();
dismiss();
}取消dialog。好吧，下面还有轨迹球：
* 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.
* 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) {
}实现该方法来处理触屏事件. 一般的动作事件，描述操纵杆移动、鼠标悬停、触控板事件、滚轮移动以及其他输入事件. 动作指定了接收到事件的类型.实现该方法必须 必须在处理事件之前检测动作源的标志位.下面是如果处理的示例代码. 发生源为&&的动作事件发送到光标下的视图. 所有其他发生源的动作时间发送到拥有焦点的视图.这里还是不做任何处理。（众所周知，现在轨迹球已经基本消失） 当Window的属性发生改变时，会重新设置属性：public void onWindowAttributesChanged(WindowManager.LayoutParams params) {
if (mDecor != null) {
mWindowManager.updateViewLayout(mDecor, params);
}当内容、焦点、Window添加或移除View都没有处理。 public void onContentChanged() {
public void onWindowFocusChanged(boolean hasFocus) {
public void onAttachedToWindow() {
public void onDetachedFromWindow() {
} 下面几个方法就是把一系列点击、触屏、滑动轨迹球等事件往上分发传递否则就调用本类中方法处理，你也可以在重写这些方法使它在向上分发传递事件之前做一些自己的事。
* 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))) {
if (mWindow.superDispatchKeyEvent(event)) {
return event.dispatch(this, mDecor != null
? mDecor.getKeyDispatcherState() : null, this);
* 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.
* @param event The key shortcut event.
* @return True if this event was consumed.
public boolean dispatchKeyShortcutEvent(KeyEvent event) {
if (mWindow.superDispatchKeyShortcutEvent(event)) {
return onKeyShortcut(event.getKeyCode(), event);
* Called to process touch screen events.
You can override this to
* intercept all touch screen events before they are dispatched to the
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 onTouchEvent(ev);
* Called to process trackball events.
You can override this to
* intercept all trackball events before they are dispatched to the
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 onTrackballEvent(ev);
* Called to process generic motion events.
You can override this to
* intercept all generic motion events before they are dispatched to the
Be sure to call this implementation for generic motion events
* that should be handled normally.
* @param ev The generic motion event.
* @return boolean Return true if this event was consumed.
public boolean dispatchGenericMotionEvent(MotionEvent ev) {
if (mWindow.superDispatchGenericMotionEvent(ev)) {
return onGenericMotionEvent(ev);
} 分发传递dispatchPopulateAccessibilityEvent:public boolean dispatchPopulateAccessibilityEvent(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);
* @see Activity#onCreatePanelView(int)
public View onCreatePanelView(int featureId) {
}实现Window.Callback接口的onCreatePanelView方法，简单的实现就是返回null。/**
* @see Activity#onCreatePanelMenu(int, Menu)
public boolean onCreatePanelMenu(int featureId, Menu menu) {
if (featureId == Window.FEATURE_OPTIONS_PANEL) {
return onCreateOptionsMenu(menu);
}创建一个菜单，实现Window.Callback接口的onCreatePanelMenu方法。
* @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();
}实现Window.Callback接口的onPreparePanel方法。每次当panel窗口显示前，都会调用该函数，返回true显示，false则不显示。
* @see Activity#onMenuOpened(int, Menu)
public boolean onMenuOpened(int featureId, Menu menu) {
if (featureId == Window.FEATURE_ACTION_BAR) {
mActionBar.dispatchMenuVisibilityChanged(true);
}实现Window.Callback接口的方法。当菜单打开时，调用该方法。
* @see Activity#onMenuItemSelected(int, MenuItem)
public boolean onMenuItemSelected(int featureId, MenuItem item) {
}实现Window.Callback接口的onMenuItemSelected方法。不做任何处理。
* @see Activity#onPanelClosed(int, Menu)
public void onPanelClosed(int featureId, Menu menu) {
if (featureId == Window.FEATURE_ACTION_BAR) {
mActionBar.dispatchMenuVisibilityChanged(false);
}实现Window.Callback接口的onPanelClosed方法。当featureId为Window.FEATURE_ACTION_BAR时，修改ActionBar的分发事件。
* 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) {
}调用创建该Dialog的Activity的onCreateOptionMenu方法。/**
* 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) {
}调用创建Activity的onCreatePrepareOptionsMenu方法。
* @see Activity#onOptionsItemSelected(MenuItem)
public boolean onOptionsItemSelected(MenuItem item) {
* @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#invalidateOptionsMenu()
public void invalidateOptionsMenu() {
mWindow.invalidatePanelMenu(Window.FEATURE_OPTIONS_PANEL);
}对选项菜单的三个操作，均是调用的Window类里面的方法。/**
* @see Activity#onCreateContextMenu(ContextMenu, View, ContextMenuInfo)
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
}创建上下文菜单，未处理。 为一个View注册和取消注册一个上下文菜单：
* @see Activity#registerForContextMenu(View)
public void registerForContextMenu(View view) {
view.setOnCreateContextMenuListener(this);
* @see Activity#unregisterForContextMenu(View)
public void unregisterForContextMenu(View view) {
view.setOnCreateContextMenuListener(null);
} 打开一个View的上下文菜单：
* @see Activity#openContextMenu(View)
public void openContextMenu(View view) {
view.showContextMenu();
* @see Activity#onContextItemSelected(MenuItem)
public boolean onContextItemSelected(MenuItem item) {
}上下文菜单选项被处理，未做任何事情。
* @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() {
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();
}这个钩子方法会在用户想要搜索的时候被调用。 public ActionMode onWindowStartingActionMode(ActionMode.Callback callback) {
if (mActionBar != null) {
return mActionBar.startActionMode(callback);
}通过系统给Activity一个控制UI操作模式（Give the Activity a chance to control the UI for an action mode requested by the system.）/**
* {@inheritDoc}
* Note that if you override this method you should always call through
* to the superclass implementation by calling super.onActionModeStarted(mode).
public void onActionModeStarted(ActionMode mode) {
mActionMode =
* {@inheritDoc}
* Note that if you override this method you should always call through
* to the superclass implementation by calling super.onActionModeFinished(mode).
public void onActionModeFinished(ActionMode mode) {
if (mode == mActionMode) {
mActionMode =
}注意,如果你重写这个方法，你一定要调用父类的super.onActionModeFinished(mode)。开始时候设置mode，结束时把mode设为空。 /**
* @return The activity associated with this dialog, or null if there is no associated activity.
private ComponentName getAssociatedActivity() {
Activity activity = mOwnerA
Context context = getContext();
while (activity == null && context != null) {
if (context instanceof Activity) {
activity = (Activity)
// found it!
context = (context instanceof ContextWrapper) ?
((ContextWrapper) context).getBaseContext() : // unwrap one level
return activity == null ? null : activity.getComponentName();
}返回相关联activity的名字。/**
* 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);
}请求来自Dialog的的按键事件，如果dialog上面没有view获取焦点，而且这个dialog想要处理按键事件，就调用该方法。
* 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
* @see android.view.Window#requestFeature
public final boolean requestWindowFeature(int featureId) {
return getWindow().requestFeature(featureId);
}设置window的属性。/**
* 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);
}设置一系列的drawable特性。
* Sets whether this dialog is cancelable with the
* {@link KeyEvent#KEYCODE_BACK BACK} key.
public void setCancelable(boolean flag) {
mCancelable =
}设置dialog是否可以取消。
* 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 =
mWindow.setCloseOnTouchOutside(cancel);
}设置当触摸dialog外部时，dialog是否可以取消。 /**
* 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
* {@link #setOnDismissListener}.
* @param listener The {@link DialogInterface.OnCancelListener} to use.
public void setOnCancelListener(final OnCancelListener listener) {
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);
mCancelMessage =
}设置一个当dialog被取消时，会被调用的监听。/**
* 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 =
}当dialog被取消时，设置发送的信息。
* 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 (mCancelAndDismissTaken != null) {
throw new IllegalStateException(
&OnDismissListener is already taken by &
+ mCancelAndDismissTaken + & and can not be replaced.&);
if (listener != null) {
mDismissMessage = mListenersHandler.obtainMessage(DISMISS, listener);
mDismissMessage =
设置一个当dialog被销毁时，会被调用的监听。
* Sets a listener to be invoked when the dialog is shown.
* @param listener The {@link DialogInterface.OnShowListener} to use.
public void setOnShowListener(OnShowListener listener) {
if (listener != null) {
mShowMessage = mListenersHandler.obtainMessage(SHOW, listener);
mShowMessage =
}设置一个当dialog显示时，会被调用的监听。
* 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 =
}设置dialog被销毁时，发送的信息。/** @hide */
public boolean takeCancelAndDismissListeners(String msg, final OnCancelListener cancel,
final OnDismissListener dismiss) {
if (mCancelAndDismissTaken != null) {
mCancelAndDismissTaken =
} else if (mCancelMessage != null || mDismissMessage != null) {
setOnCancelListener(cancel);
setOnDismissListener(dismiss);
mCancelAndDismissTaken =
}同时设置OnCancelListener和OnDismissListener。
* 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();
}设置和获取Dialog所属的Activity中音量控制键控制的音频流。
* Sets the callback that will be called if a key is dispatched to the dialog.
public void setOnKeyListener(final OnKeyListener onKeyListener) {
mOnKeyListener = onKeyL
}设置一个回调，当按键事件被分发到dialog 回调函数会被调用。private static final class ListenersHandler extends Handler {
private WeakReference&DialogInterface& mD
public ListenersHandler(Dialog dialog) {
mDialog = new WeakReference&DialogInterface&(dialog);
public void handleMessage(Message msg) {
switch (msg.what) {
case DISMISS:
((OnDismissListener) msg.obj).onDismiss(mDialog.get());
case CANCEL:
((OnCancelListener) msg.obj).onCancel(mDialog.get());
case SHOW:
((OnShowListener) msg.obj).onShow(mDialog.get());
}ListenersHandler的定义。 将近3点了，有点困，想睡了。。。查看更多源码内容：！
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1218728次
积分：13470
积分：13470
排名：第278名
原创：162篇
转载：26篇
评论：1461条
文章：10篇
阅读：72010
文章：57篇
阅读：431813
文章：31篇
阅读：353943
文章：19篇
阅读：122081
(1)(1)(4)(4)(1)(1)(2)(1)(2)(4)(2)(4)(3)(2)(1)(4)(4)(11)(4)(3)(1)(4)(7)(15)(5)(8)(4)(4)(8)(16)(3)(13)(14)(20)(2)(1)(1)(3)(2)(1)(1)