| Methods Summary |
|---|
| public abstract void | addContentView(View view, ViewGroup.LayoutParams params)Variation on
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)}
to add an additional content view to the screen. Added after any existing
ones in the screen -- existing views are NOT removed.
|
| public void | addFlags(int flags)Convenience function to set the flag bits as specified in flags, as
per {@link #setFlags}.
setFlags(flags, flags);
|
| public void | addPrivateFlags(int flags)
setPrivateFlags(flags, flags);
|
| void | adjustLayoutParamsForSubWindow(WindowManager.LayoutParams wp)
CharSequence curTitle = wp.getTitle();
if (wp.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
wp.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
if (wp.token == null) {
View decor = peekDecorView();
if (decor != null) {
wp.token = decor.getWindowToken();
}
}
if (curTitle == null || curTitle.length() == 0) {
String title;
if (wp.type == WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA) {
title="Media";
} else if (wp.type == WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY) {
title="MediaOvr";
} else if (wp.type == WindowManager.LayoutParams.TYPE_APPLICATION_PANEL) {
title="Panel";
} else if (wp.type == WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL) {
title="SubPanel";
} else if (wp.type == WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG) {
title="AtchDlg";
} else {
title=Integer.toString(wp.type);
}
if (mAppName != null) {
title += ":" + mAppName;
}
wp.setTitle(title);
}
} else {
if (wp.token == null) {
wp.token = mContainer == null ? mAppToken : mContainer.mAppToken;
}
if ((curTitle == null || curTitle.length() == 0)
&& mAppName != null) {
wp.setTitle(mAppName);
}
}
if (wp.packageName == null) {
wp.packageName = mContext.getPackageName();
}
if (mHardwareAccelerated) {
wp.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
}
|
| public abstract void | alwaysReadCloseOnTouchAttr()
|
| public void | clearFlags(int flags)Convenience function to clear the flag bits as specified in flags, as
per {@link #setFlags}.
setFlags(0, flags);
|
| public abstract void | closeAllPanels()
|
| public abstract void | closePanel(int featureId)
|
| public final void | destroy()
mDestroyed = true;
|
| public final void | dispatchOnWindowDismissed()
if (mOnWindowDismissedCallback != null) {
mOnWindowDismissedCallback.onWindowDismissed();
}
|
| protected void | dispatchWindowAttributesChanged(WindowManager.LayoutParams attrs){@hide}
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
|
| public View | findViewById(int id)Finds a view that was identified by the id attribute from the XML that
was processed in {@link android.app.Activity#onCreate}. This will
implicitly call {@link #getDecorView} for you, with all of the
associated side-effects.
return getDecorView().findViewById(id);
|
| public boolean | getAllowEnterTransitionOverlap()Returns how the transition set in
{@link #setEnterTransition(android.transition.Transition)} overlaps with the exit
transition of the calling Activity. When true, the transition will start as soon as possible.
When false, the transition will wait until the remote exiting transition completes before
starting. return true;
|
| public boolean | getAllowExitTransitionOverlap()TODO: remove this. return getAllowReturnTransitionOverlap();
|
| public boolean | getAllowReturnTransitionOverlap()Returns how the transition set in
{@link #setExitTransition(android.transition.Transition)} overlaps with the exit
transition of the called Activity when reentering after if finishes. When true,
the transition will start as soon as possible. When false, the transition will wait
until the called Activity's exiting transition completes before starting. return true;
|
| public final WindowManager.LayoutParams | getAttributes()Retrieve the current window attributes associated with this panel.
return mWindowAttributes;
|
| public final android.view.Window$Callback | getCallback()Return the current Callback interface for this window.
return mCallback;
|
| public final android.view.Window | getContainer()Return the container for this Window.
return mContainer;
|
| public android.transition.Scene | getContentScene()Retrieve the {@link Scene} representing this window's current content.
Requires {@link #FEATURE_CONTENT_TRANSITIONS}.
This method will return null if the current content is not represented by a Scene.
return null;
|
| public final android.content.Context | getContext()Return the Context this window policy is running in, for retrieving
resources and other information.
return mContext;
|
| public abstract View | getCurrentFocus()Return the view in this Window that currently has focus, or null if
there are none. Note that this does not look in any containing
Window.
|
| public abstract View | getDecorView()Retrieve the top-level window decor view (containing the standard
window frame/decorations and the client's content inside of that), which
can be added as a window to the window manager.
Note that calling this function for the first time "locks in"
various window characteristics as described in
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)}.
|
| public static int | getDefaultFeatures(android.content.Context context)Return the feature bits set by default on a window.
int features = 0;
final Resources res = context.getResources();
if (res.getBoolean(com.android.internal.R.bool.config_defaultWindowFeatureOptionsPanel)) {
features |= 1 << FEATURE_OPTIONS_PANEL;
}
if (res.getBoolean(com.android.internal.R.bool.config_defaultWindowFeatureContextMenu)) {
features |= 1 << FEATURE_CONTEXT_MENU;
}
return features;
|
| public android.transition.Transition | getEnterTransition()Returns the transition used to move Views into the initial scene. The entering
Views will be those that are regular Views or ViewGroups that have
{@link ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as entering is governed by changing visibility from
{@link View#INVISIBLE} to {@link View#VISIBLE}. If transition is null,
entering Views will remain unaffected. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. return null;
|
| public android.transition.Transition | getExitTransition()Returns the Transition that will be used to move Views out of the scene when starting a
new Activity. The exiting Views will be those that are regular Views or ViewGroups that
have {@link ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as exiting is governed by changing visibility
from {@link View#VISIBLE} to {@link View#INVISIBLE}. If transition is null, the views will
remain unaffected. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. return null;
|
| protected final int | getFeatures()Return the feature bits that are enabled. This is the set of features
that were given to requestFeature(), and are being handled by this
Window itself or its container. That is, it is the set of
requested features that you can actually use.
To do: add a public version of this API that allows you to check for
features by their feature ID.
return mFeatures;
|
| protected final int | getForcedWindowFlags()Return the window flags that have been explicitly set by the client,
so will not be modified by {@link #getDecorView}.
return mForcedWindowFlags;
|
| public abstract LayoutInflater | getLayoutInflater()Quick access to the {@link LayoutInflater} instance that this Window
retrieved from its Context.
|
| protected final int | getLocalFeatures()Return the feature bits that are being implemented by this Window.
This is the set of features that were given to requestFeature(), and are
being handled by only this Window itself, not by its containers.
return mLocalFeatures;
|
| public android.media.session.MediaController | getMediaController()Gets the {@link MediaController} that was previously set.
return null;
|
| public abstract int | getNavigationBarColor()
|
| public android.transition.Transition | getReenterTransition()Returns the Transition that will be used to move Views in to the scene when returning from
a previously-started Activity. The entering Views will be those that are regular Views
or ViewGroups that have {@link ViewGroup#isTransitionGroup} return true. Typical Transitions
will extend {@link android.transition.Visibility} as exiting is governed by changing
visibility from {@link View#VISIBLE} to {@link View#INVISIBLE}.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. return null;
|
| public android.transition.Transition | getReturnTransition()Returns he Transition that will be used to move Views out of the scene when the Window is
preparing to close, for example after a call to
{@link android.app.Activity#finishAfterTransition()}. The exiting
Views will be those that are regular Views or ViewGroups that have
{@link ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as entering is governed by changing visibility from
{@link View#VISIBLE} to {@link View#INVISIBLE}. return null;
|
| public android.transition.Transition | getSharedElementEnterTransition()Returns the Transition that will be used for shared elements transferred into the content
Scene. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. return null;
|
| public android.transition.Transition | getSharedElementExitTransition()Returns the Transition to use for shared elements in the launching Window prior
to transferring to the launched Activity's Window.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. return null;
|
| public android.transition.Transition | getSharedElementReenterTransition()Returns the Transition that will be used for shared elements reentering from a started
Activity after it has returned the shared element to it start location.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. return null;
|
| public android.transition.Transition | getSharedElementReturnTransition()Returns the Transition that will be used for shared elements transferred back to a
calling Activity. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. return null;
|
| public boolean | getSharedElementsUseOverlay()Returns true when shared elements should use an Overlay during
shared element transitions or false when they should animate as
part of the normal View hierarchy. The default value is true. return true;
|
| public abstract int | getStatusBarColor()
|
| public long | getTransitionBackgroundFadeDuration()Returns the duration, in milliseconds, of the window background fade
when transitioning into or away from an Activity when called with an Activity Transition.
When executing the enter transition, the background starts transparent
and fades in. This requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. The default is
300 milliseconds. return 0;
|
| public android.transition.TransitionManager | getTransitionManager()Retrieve the {@link TransitionManager} responsible for for default transitions
in this window. Requires {@link #FEATURE_CONTENT_TRANSITIONS}.
This method will return non-null after content has been initialized (e.g. by using
{@link #setContentView}) if {@link #FEATURE_CONTENT_TRANSITIONS} has been granted.
return null;
|
| public abstract int | getVolumeControlStream()
|
| public WindowManager | getWindowManager()Return the window manager allowing this Window to display its own
windows.
return mWindowManager;
|
| public final android.content.res.TypedArray | getWindowStyle()Return the {@link android.R.styleable#Window} attributes from this
window's theme.
synchronized (this) {
if (mWindowStyle == null) {
mWindowStyle = mContext.obtainStyledAttributes(
com.android.internal.R.styleable.Window);
}
return mWindowStyle;
}
|
| public final boolean | hasChildren()
return mHasChildren;
|
| public boolean | hasFeature(int feature)Query for the availability of a certain feature.
return (getFeatures() & (1 << feature)) != 0;
|
| protected final boolean | hasSoftInputMode()Has the app specified their own soft input mode?
return mHasSoftInputMode;
|
| protected boolean | haveDimAmount()
return mHaveDimAmount;
|
| public void | injectInputEvent(InputEvent event)Inject an event to window locally.
|
| public abstract void | invalidatePanelMenu(int featureId)
|
| public final boolean | isActive()
return mIsActive;
|
| public final boolean | isDestroyed()
return mDestroyed;
|
| public abstract boolean | isFloating()Return whether this window is being displayed with a floating style
(based on the {@link android.R.attr#windowIsFloating} attribute in
the style/theme).
|
| private boolean | isOutOfBounds(android.content.Context context, MotionEvent event)
final int x = (int) event.getX();
final int y = (int) event.getY();
final int slop = ViewConfiguration.get(context).getScaledWindowTouchSlop();
final View decorView = getDecorView();
return (x < -slop) || (y < -slop)
|| (x > (decorView.getWidth()+slop))
|| (y > (decorView.getHeight()+slop));
|
| public abstract boolean | isShortcutKey(int keyCode, KeyEvent event)Is a keypress one of the defined shortcut keys for this window.
|
| public final void | makeActive()
if (mContainer != null) {
if (mContainer.mActiveChild != null) {
mContainer.mActiveChild.mIsActive = false;
}
mContainer.mActiveChild = this;
}
mIsActive = true;
onActive();
|
| protected abstract void | onActive()
|
| public abstract void | onConfigurationChanged(android.content.res.Configuration newConfig)Should be called when the configuration is changed.
|
| public abstract void | openPanel(int featureId, KeyEvent event)
|
| public abstract View | peekDecorView()Retrieve the current decor view, but only if it has already been created;
otherwise returns null.
|
| public abstract boolean | performContextMenuIdentifierAction(int id, int flags)
|
| public abstract boolean | performPanelIdentifierAction(int featureId, int id, int flags)
|
| public abstract boolean | performPanelShortcut(int featureId, int keyCode, KeyEvent event, int flags)
|
| protected void | removeFeature(int featureId)
final int flag = 1<<featureId;
mFeatures &= ~flag;
mLocalFeatures &= ~(mContainer != null ? (flag&~mContainer.mFeatures) : flag);
|
| public boolean | requestFeature(int featureId)Enable extended screen features. This must be called before
setContentView(). May be called as many times as desired as long as it
is before setContentView(). If not called, no extended features
will be available. You can not turn off a feature once it is requested.
You canot use other title features with {@link #FEATURE_CUSTOM_TITLE}.
final int flag = 1<<featureId;
mFeatures |= flag;
mLocalFeatures |= mContainer != null ? (flag&~mContainer.mFeatures) : flag;
return (mFeatures&flag) != 0;
|
| public abstract void | restoreHierarchyState(android.os.Bundle savedInstanceState)
|
| public abstract android.os.Bundle | saveHierarchyState()
|
| public void | setAllowEnterTransitionOverlap(boolean allow)Controls how the transition set in
{@link #setEnterTransition(android.transition.Transition)} overlaps with the exit
transition of the calling Activity. When true, the transition will start as soon as possible.
When false, the transition will wait until the remote exiting transition completes before
starting.
|
| public void | setAllowExitTransitionOverlap(boolean allow)TODO: remove this.
setAllowReturnTransitionOverlap(allow);
|
| public void | setAllowReturnTransitionOverlap(boolean allow)Controls how the transition set in
{@link #setExitTransition(android.transition.Transition)} overlaps with the exit
transition of the called Activity when reentering after if finishes. When true,
the transition will start as soon as possible. When false, the transition will wait
until the called Activity's exiting transition completes before starting.
|
| public void | setAttributes(WindowManager.LayoutParams a)Specify custom window attributes. PLEASE NOTE: the
layout params you give here should generally be from values previously
retrieved with {@link #getAttributes()}; you probably do not want to
blindly create and apply your own, since this will blow away any values
set by the framework that you are not interested in.
mWindowAttributes.copyFrom(a);
dispatchWindowAttributesChanged(mWindowAttributes);
|
| public abstract void | setBackgroundDrawable(android.graphics.drawable.Drawable drawable)Change the background of this window to a custom Drawable. Setting the
background to null will make the window be opaque. To make the window
transparent, you can use an empty drawable (for instance a ColorDrawable
with the color 0 or the system drawable android:drawable/empty.)
|
| public void | setBackgroundDrawableResource(int resId)Change the background of this window to a Drawable resource. Setting the
background to null will make the window be opaque. To make the window
transparent, you can use an empty drawable (for instance a ColorDrawable
with the color 0 or the system drawable android:drawable/empty.)
setBackgroundDrawable(mContext.getDrawable(resId));
|
| public void | setCallback(android.view.Window$Callback callback)Set the Callback interface for this window, used to intercept key
events and other dynamic operations in the window.
mCallback = callback;
|
| public abstract void | setChildDrawable(int featureId, android.graphics.drawable.Drawable drawable)
|
| public abstract void | setChildInt(int featureId, int value)
|
| public void | setClipToOutline(boolean clipToOutline)Sets whether window content should be clipped to the outline of the
window background.
|
| public void | setCloseOnTouchOutside(boolean close)
mCloseOnTouchOutside = close;
mSetCloseOnTouchOutside = true;
|
| public void | setCloseOnTouchOutsideIfNotSet(boolean close)
if (!mSetCloseOnTouchOutside) {
mCloseOnTouchOutside = close;
mSetCloseOnTouchOutside = true;
}
|
| public void | setContainer(android.view.Window container)Set the container for this window. If not set, the DecorWindow
operates as a top-level window; otherwise, it negotiates with the
container to display itself appropriately.
mContainer = container;
if (container != null) {
// Embedded screens never have a title.
mFeatures |= 1<<FEATURE_NO_TITLE;
mLocalFeatures |= 1<<FEATURE_NO_TITLE;
container.mHasChildren = true;
}
|
| public abstract void | setContentView(int layoutResID)Convenience for
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)}
to set the screen content from a layout resource. The resource will be
inflated, adding all top-level views to the screen.
|
| public abstract void | setContentView(View view)Convenience for
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)}
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.
|
| public abstract void | setContentView(View 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 hierarchy.
Note that calling this function "locks in" various characteristics
of the window that can not, from this point forward, be changed: the
features that have been requested with {@link #requestFeature(int)},
and certain window flags as described in {@link #setFlags(int, int)}.
If {@link #FEATURE_CONTENT_TRANSITIONS} is set, the window's
TransitionManager will be used to animate content from the current
content View to view.
|
| public void | setDefaultIcon(int resId)Set the default icon for this window.
This will be overridden by any other icon set operation which could come from the
theme or another explicit set.
|
| public void | setDefaultLogo(int resId)Set the default logo for this window.
This will be overridden by any other logo set operation which could come from the
theme or another explicit set.
|
| protected void | setDefaultWindowFormat(int format)Set the default format of window, as per the PixelFormat types. This
is the format that will be used unless the client specifies in explicit
format with setFormat();
mDefaultWindowFormat = format;
if (!mHaveWindowFormat) {
final WindowManager.LayoutParams attrs = getAttributes();
attrs.format = format;
dispatchWindowAttributesChanged(attrs);
}
|
| public void | setDimAmount(float amount)Set the amount of dim behind the window when using
{@link WindowManager.LayoutParams#FLAG_DIM_BEHIND}. This overrides
the default dim amount of that is selected by the Window based on
its theme.
final WindowManager.LayoutParams attrs = getAttributes();
attrs.dimAmount = amount;
mHaveDimAmount = true;
dispatchWindowAttributesChanged(attrs);
|
| public void | setDisableWallpaperTouchEvents(boolean disable)
setPrivateFlags(disable
? WindowManager.LayoutParams.PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS : 0,
WindowManager.LayoutParams.PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS);
|
| public void | setElevation(float elevation)Sets the window elevation.
Changes to this property take effect immediately and will cause the
window surface to be recreated. This is an expensive operation and as a
result, this property should not be animated.
|
| public void | setEnterTransition(android.transition.Transition transition)Sets the Transition that will be used to move Views into the initial scene. The entering
Views will be those that are regular Views or ViewGroups that have
{@link ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as entering is governed by changing visibility from
{@link View#INVISIBLE} to {@link View#VISIBLE}. If transition is null,
entering Views will remain unaffected.
|
| public void | setExitTransition(android.transition.Transition transition)Sets the Transition that will be used to move Views out of the scene when starting a
new Activity. The exiting Views will be those that are regular Views or ViewGroups that
have {@link ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as exiting is governed by changing visibility
from {@link View#VISIBLE} to {@link View#INVISIBLE}. If transition is null, the views will
remain unaffected. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
|
| public abstract void | setFeatureDrawable(int featureId, android.graphics.drawable.Drawable drawable)Set an explicit Drawable value for feature of this window. You must
have called requestFeature(featureId) before calling this function.
|
| public abstract void | setFeatureDrawableAlpha(int featureId, int alpha)Set a custom alpha value for the given drawable feature, controlling how
much the background is visible through it.
|
| public abstract void | setFeatureDrawableResource(int featureId, int resId)Set the value for a drawable feature of this window, from a resource
identifier. You must have called requestFeauture(featureId) before
calling this function.
|
| public abstract void | setFeatureDrawableUri(int featureId, android.net.Uri uri)Set the value for a drawable feature of this window, from a URI. You
must have called requestFeature(featureId) before calling this
function.
The only URI currently supported is "content:", specifying an image
in a content provider.
|
| public abstract void | setFeatureInt(int featureId, int value)Set the integer value for a feature. The range of the value depends on
the feature being set. For {@link #FEATURE_PROGRESS}, it should go from
0 to 10000. At 10000 the progress is complete and the indicator hidden.
|
| public void | setFlags(int flags, int mask)Set the flags of the window, as per the
{@link WindowManager.LayoutParams WindowManager.LayoutParams}
flags.
Note that some flags must be set before the window decoration is
created (by the first call to
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)} or
{@link #getDecorView()}:
{@link WindowManager.LayoutParams#FLAG_LAYOUT_IN_SCREEN} and
{@link WindowManager.LayoutParams#FLAG_LAYOUT_INSET_DECOR}. These
will be set for you based on the {@link android.R.attr#windowIsFloating}
attribute.
final WindowManager.LayoutParams attrs = getAttributes();
attrs.flags = (attrs.flags&~mask) | (flags&mask);
mForcedWindowFlags |= mask;
dispatchWindowAttributesChanged(attrs);
|
| public void | setFormat(int format)Set the format of window, as per the PixelFormat types. This overrides
the default format that is selected by the Window based on its
window decorations.
final WindowManager.LayoutParams attrs = getAttributes();
if (format != PixelFormat.UNKNOWN) {
attrs.format = format;
mHaveWindowFormat = true;
} else {
attrs.format = mDefaultWindowFormat;
mHaveWindowFormat = false;
}
dispatchWindowAttributesChanged(attrs);
|
| public void | setGravity(int gravity)Set the gravity of the window, as per the Gravity constants. This
controls how the window manager is positioned in the overall window; it
is only useful when using WRAP_CONTENT for the layout width or height.
final WindowManager.LayoutParams attrs = getAttributes();
attrs.gravity = gravity;
dispatchWindowAttributesChanged(attrs);
|
| public void | setIcon(int resId)Set the primary icon for this window.
|
| public void | setLayout(int width, int height)Set the width and height layout parameters of the window. The default
for both of these is MATCH_PARENT; you can change them to WRAP_CONTENT
or an absolute value to make a window that is not full-screen.
final WindowManager.LayoutParams attrs = getAttributes();
attrs.width = width;
attrs.height = height;
dispatchWindowAttributesChanged(attrs);
|
| public void | setLocalFocus(boolean hasFocus, boolean inTouchMode)Set focus locally. The window should have the
{@link WindowManager.LayoutParams#FLAG_LOCAL_FOCUS_MODE} flag set already.
|
| public void | setLogo(int resId)Set the logo for this window. A logo is often shown in place of an
{@link #setIcon(int) icon} but is generally wider and communicates window title information
as well.
|
| public void | setMediaController(android.media.session.MediaController controller)Sets a {@link MediaController} to send media keys and volume changes to.
If set, this should be preferred for all media keys and volume requests
sent to this window.
|
| public abstract void | setNavigationBarColor(int color)Sets the color of the navigation bar to {@param color}.
For this to take effect,
the window must be drawing the system bar backgrounds with
{@link android.view.WindowManager.LayoutParams#FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS} and
{@link android.view.WindowManager.LayoutParams#FLAG_TRANSLUCENT_NAVIGATION} must not be set.
If {@param color} is not opaque, consider setting
{@link android.view.View#SYSTEM_UI_FLAG_LAYOUT_STABLE} and
{@link android.view.View#SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION}.
The transitionName for the view background will be "android:navigation:background".
|
| protected void | setNeedsMenuKey(int value){@hide}
final WindowManager.LayoutParams attrs = getAttributes();
attrs.needsMenuKey = value;
dispatchWindowAttributesChanged(attrs);
|
| public final void | setOnWindowDismissedCallback(android.view.Window$OnWindowDismissedCallback dcb)
mOnWindowDismissedCallback = dcb;
|
| private void | setPrivateFlags(int flags, int mask)
final WindowManager.LayoutParams attrs = getAttributes();
attrs.privateFlags = (attrs.privateFlags & ~mask) | (flags & mask);
dispatchWindowAttributesChanged(attrs);
|
| public void | setReenterTransition(android.transition.Transition transition)Sets the Transition that will be used to move Views in to the scene when returning from
a previously-started Activity. The entering Views will be those that are regular Views
or ViewGroups that have {@link ViewGroup#isTransitionGroup} return true. Typical Transitions
will extend {@link android.transition.Visibility} as exiting is governed by changing
visibility from {@link View#VISIBLE} to {@link View#INVISIBLE}. If transition is null,
the views will remain unaffected. If nothing is set, the default will be to use the same
transition as {@link #setExitTransition(android.transition.Transition)}.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
|
| public void | setReturnTransition(android.transition.Transition transition)Sets the Transition that will be used to move Views out of the scene when the Window is
preparing to close, for example after a call to
{@link android.app.Activity#finishAfterTransition()}. The exiting
Views will be those that are regular Views or ViewGroups that have
{@link ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as entering is governed by changing visibility from
{@link View#VISIBLE} to {@link View#INVISIBLE}. If transition is null,
entering Views will remain unaffected. If nothing is set, the default will be to
use the same value as set in {@link #setEnterTransition(android.transition.Transition)}.
|
| public void | setSharedElementEnterTransition(android.transition.Transition transition)Sets the Transition that will be used for shared elements transferred into the content
Scene. Typical Transitions will affect size and location, such as
{@link android.transition.ChangeBounds}. A null
value will cause transferred shared elements to blink to the final position.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
|
| public void | setSharedElementExitTransition(android.transition.Transition transition)Sets the Transition that will be used for shared elements after starting a new Activity
before the shared elements are transferred to the called Activity. If the shared elements
must animate during the exit transition, this Transition should be used. Upon completion,
the shared elements may be transferred to the started Activity.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
|
| public void | setSharedElementReenterTransition(android.transition.Transition transition)Sets the Transition that will be used for shared elements reentering from a started
Activity after it has returned the shared element to it start location. If no value
is set, this will default to
{@link #setSharedElementExitTransition(android.transition.Transition)}.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
|
| public void | setSharedElementReturnTransition(android.transition.Transition transition)Sets the Transition that will be used for shared elements transferred back to a
calling Activity. Typical Transitions will affect size and location, such as
{@link android.transition.ChangeBounds}. A null
value will cause transferred shared elements to blink to the final position.
If no value is set, the default will be to use the same value as
{@link #setSharedElementEnterTransition(android.transition.Transition)}.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
|
| public void | setSharedElementsUseOverlay(boolean sharedElementsUseOverlay)Sets whether or not shared elements should use an Overlay during shared element transitions.
The default value is true.
|
| public void | setSoftInputMode(int mode)Specify an explicit soft input mode to use for the window, as per
{@link WindowManager.LayoutParams#softInputMode
WindowManager.LayoutParams.softInputMode}. Providing anything besides
"unspecified" here will override the input mode the window would
normally retrieve from its theme.
final WindowManager.LayoutParams attrs = getAttributes();
if (mode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
attrs.softInputMode = mode;
mHasSoftInputMode = true;
} else {
mHasSoftInputMode = false;
}
dispatchWindowAttributesChanged(attrs);
|
| public abstract void | setStatusBarColor(int color)Sets the color of the status bar to {@param color}.
For this to take effect,
the window must be drawing the system bar backgrounds with
{@link android.view.WindowManager.LayoutParams#FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS} and
{@link android.view.WindowManager.LayoutParams#FLAG_TRANSLUCENT_STATUS} must not be set.
If {@param color} is not opaque, consider setting
{@link android.view.View#SYSTEM_UI_FLAG_LAYOUT_STABLE} and
{@link android.view.View#SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN}.
The transitionName for the view background will be "android:status:background".
|
| public abstract void | setTitle(java.lang.CharSequence title)
|
| public abstract void | setTitleColor(int textColor)
|
| public void | setTransitionBackgroundFadeDuration(long fadeDurationMillis)Sets the duration, in milliseconds, of the window background fade
when transitioning into or away from an Activity when called with an Activity Transition.
When executing the enter transition, the background starts transparent
and fades in. This requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. The default is
300 milliseconds.
|
| public void | setTransitionManager(android.transition.TransitionManager tm)Set the {@link TransitionManager} to use for default transitions in this window.
Requires {@link #FEATURE_CONTENT_TRANSITIONS}.
throw new UnsupportedOperationException();
|
| public void | setType(int type)Set the type of the window, as per the WindowManager.LayoutParams
types.
final WindowManager.LayoutParams attrs = getAttributes();
attrs.type = type;
dispatchWindowAttributesChanged(attrs);
|
| public void | setUiOptions(int uiOptions, int mask)Set extra options that will influence the UI for this window.
Only the bits filtered by mask will be modified.
|
| public void | setUiOptions(int uiOptions)Set extra options that will influence the UI for this window.
|
| public abstract void | setVolumeControlStream(int streamType)
|
| public void | setWindowAnimations(int resId)Specify custom animations to use for the window, as per
{@link WindowManager.LayoutParams#windowAnimations
WindowManager.LayoutParams.windowAnimations}. Providing anything besides
0 here will override the animations the window would
normally retrieve from its theme.
final WindowManager.LayoutParams attrs = getAttributes();
attrs.windowAnimations = resId;
dispatchWindowAttributesChanged(attrs);
|
| public void | setWindowManager(WindowManager wm, android.os.IBinder appToken, java.lang.String appName, boolean hardwareAccelerated)Set the window manager for use by this Window to, for example,
display panels. This is not used for displaying the
Window itself -- that must be done by the client.
mAppToken = appToken;
mAppName = appName;
mHardwareAccelerated = hardwareAccelerated
|| SystemProperties.getBoolean(PROPERTY_HARDWARE_UI, false);
if (wm == null) {
wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
}
mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
|
| public void | setWindowManager(WindowManager wm, android.os.IBinder appToken, java.lang.String appName)Set the window manager for use by this Window to, for example,
display panels. This is not used for displaying the
Window itself -- that must be done by the client.
setWindowManager(wm, appToken, appName, false);
|
| public boolean | shouldCloseOnTouch(android.content.Context context, MotionEvent event)
if (mCloseOnTouchOutside && event.getAction() == MotionEvent.ACTION_DOWN
&& isOutOfBounds(context, event) && peekDecorView() != null) {
return true;
}
return false;
|
| public abstract boolean | superDispatchGenericMotionEvent(MotionEvent event)Used by custom windows, such as Dialog, to pass the generic motion event
further down the view hierarchy. Application developers should
not need to implement or call this.
|
| public abstract boolean | superDispatchKeyEvent(KeyEvent event)Used by custom windows, such as Dialog, to pass the key press event
further down the view hierarchy. Application developers should
not need to implement or call this.
|
| public abstract boolean | superDispatchKeyShortcutEvent(KeyEvent event)Used by custom windows, such as Dialog, to pass the key shortcut press event
further down the view hierarchy. Application developers should
not need to implement or call this.
|
| public abstract boolean | superDispatchTouchEvent(MotionEvent event)Used by custom windows, such as Dialog, to pass the touch screen event
further down the view hierarchy. Application developers should
not need to implement or call this.
|
| public abstract boolean | superDispatchTrackballEvent(MotionEvent event)Used by custom windows, such as Dialog, to pass the trackball event
further down the view hierarchy. Application developers should
not need to implement or call this.
|
| public abstract void | takeInputQueue(InputQueue.Callback callback)Take ownership of this window's InputQueue. The window will no
longer read and dispatch input events from the queue; it is your
responsibility to do so.
|
| public abstract void | takeKeyEvents(boolean get)Request that key events come to this activity. Use this if your
activity has no views with focus, but the activity still wants
a chance to process key events.
|
| public abstract void | takeSurface(SurfaceHolder.Callback2 callback)Take ownership of this window's surface. The window's view hierarchy
will no longer draw into the surface, though it will otherwise continue
to operate (such as for receiving input events). The given SurfaceHolder
callback will be used to tell you about state changes to the surface.
|
| public abstract void | togglePanel(int featureId, KeyEvent event)
|
