package android.view;
import android.content.pm.ActivityInfo;
import android.graphics.PixelFormat;
import android.os.IBinder;
import android.util.Log;
public class WindowManager implements ViewManager {
public static class LayoutParams extends ViewGroup.LayoutParams {
/**
* X position for this window. With the default gravity it is ignored.
* When using {@link Gravity#LEFT} or {@link Gravity#RIGHT} it provides
* an offset from the given edge.
*/
public int x;
/**
* Y position for this window. With the default gravity it is ignored.
* When using {@link Gravity#TOP} or {@link Gravity#BOTTOM} it provides
* an offset from the given edge.
*/
public int y;
/**
* Indicates how much of the extra space will be allocated horizontally
* to the view associated with these LayoutParams. Specify 0 if the view
* should not be stretched. Otherwise the extra pixels will be pro-rated
* among all views whose weight is greater than 0.
*/
public float horizontalWeight;
/**
* Indicates how much of the extra space will be allocated vertically to
* the view associated with these LayoutParams. Specify 0 if the view
* should not be stretched. Otherwise the extra pixels will be pro-rated
* among all views whose weight is greater than 0.
*/
public float verticalWeight;
public int type;
/**
* Start of window types that represent normal application windows.
*/
public static final int FIRST_APPLICATION_WINDOW = 1;
/**
* Window type: an application window that serves as the "base" window
* of the overall application; all other application windows will
* appear on top of it.
*/
public static final int TYPE_BASE_APPLICATION = 1;
/**
* Window type: a normal application window. The {@link #token} must be
* an Activity token identifying who the window belongs to.
*/
public static final int TYPE_APPLICATION = 2;
/**
* Window type: special application window that is displayed while the
* application is starting. Not for use by applications themselves;
* this is used by the system to display something until the
* application can show its own windows.
*/
public static final int TYPE_APPLICATION_STARTING = 3;
/**
* End of types of application windows.
*/
public static final int LAST_APPLICATION_WINDOW = 99;
/**
* Start of types of sub-windows. The {@link #token} of these windows
* must be set to the window they are attached to. These types of
* windows are kept next to their attached window in Z-order, and their
* coordinate space is relative to their attached window.
*/
public static final int FIRST_SUB_WINDOW = 1000;
/**
* Window type: a panel on top of an application window. These windows
* appear on top of their attached window.
*/
public static final int TYPE_APPLICATION_PANEL = FIRST_SUB_WINDOW;
/**
* Window type: window for showing media (e.g. video). These windows
* are displayed behind their attached window.
*/
public static final int TYPE_APPLICATION_MEDIA = FIRST_SUB_WINDOW+1;
/**
* Window type: a sub-panel on top of an application window. These
* windows are displayed on top their attached window and any
* {@link #TYPE_APPLICATION_PANEL} panels.
*/
public static final int TYPE_APPLICATION_SUB_PANEL = FIRST_SUB_WINDOW+2;
/** Window type: like {@link #TYPE_APPLICATION_PANEL}, but layout
* of the window happens as that of a top-level window, <em>not</em>
* as a child of its container.
*/
public static final int TYPE_APPLICATION_ATTACHED_DIALOG = FIRST_SUB_WINDOW+3;
/**
* Window type: window for showing overlays on top of media windows.
* These windows are displayed between TYPE_APPLICATION_MEDIA and the
* application window. They should be translucent to be useful. This
* is a big ugly hack so:
* @hide
*/
public static final int TYPE_APPLICATION_MEDIA_OVERLAY = FIRST_SUB_WINDOW+4;
/**
* End of types of sub-windows.
*/
public static final int LAST_SUB_WINDOW = 1999;
/**
* Start of system-specific window types. These are not normally
* created by applications.
*/
public static final int FIRST_SYSTEM_WINDOW = 2000;
/**
* Window type: the status bar. There can be only one status bar
* window; it is placed at the top of the screen, and all other
* windows are shifted down so they are below it.
*/
public static final int TYPE_STATUS_BAR = FIRST_SYSTEM_WINDOW;
/**
* Window type: the search bar. There can be only one search bar
* window; it is placed at the top of the screen.
*/
public static final int TYPE_SEARCH_BAR = FIRST_SYSTEM_WINDOW+1;
/**
* Window type: phone. These are non-application windows providing
* user interaction with the phone (in particular incoming calls).
* These windows are normally placed above all applications, but behind
* the status bar.
*/
public static final int TYPE_PHONE = FIRST_SYSTEM_WINDOW+2;
/**
* Window type: system window, such as low power alert. These windows
* are always on top of application windows.
*/
public static final int TYPE_SYSTEM_ALERT = FIRST_SYSTEM_WINDOW+3;
/**
* Window type: keyguard window.
*/
public static final int TYPE_KEYGUARD = FIRST_SYSTEM_WINDOW+4;
/**
* Window type: transient notifications.
*/
public static final int TYPE_TOAST = FIRST_SYSTEM_WINDOW+5;
/**
* Window type: system overlay windows, which need to be displayed
* on top of everything else. These windows must not take input
* focus, or they will interfere with the keyguard.
*/
public static final int TYPE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+6;
/**
* Window type: priority phone UI, which needs to be displayed even if
* the keyguard is active. These windows must not take input
* focus, or they will interfere with the keyguard.
*/
public static final int TYPE_PRIORITY_PHONE = FIRST_SYSTEM_WINDOW+7;
/**
* Window type: panel that slides out from the status bar
*/
public static final int TYPE_SYSTEM_DIALOG = FIRST_SYSTEM_WINDOW+8;
/**
* Window type: dialogs that the keyguard shows
*/
public static final int TYPE_KEYGUARD_DIALOG = FIRST_SYSTEM_WINDOW+9;
/**
* Window type: internal system error windows, appear on top of
* everything they can.
*/
public static final int TYPE_SYSTEM_ERROR = FIRST_SYSTEM_WINDOW+10;
/**
* Window type: internal input methods windows, which appear above
* the normal UI. Application windows may be resized or panned to keep
* the input focus visible while this window is displayed.
*/
public static final int TYPE_INPUT_METHOD = FIRST_SYSTEM_WINDOW+11;
/**
* Window type: internal input methods dialog windows, which appear above
* the current input method window.
*/
public static final int TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12;
/**
* Window type: wallpaper window, placed behind any window that wants
* to sit on top of the wallpaper.
*/
public static final int TYPE_WALLPAPER = FIRST_SYSTEM_WINDOW+13;
/**
* Window type: panel that slides out from the status bar
*/
public static final int TYPE_STATUS_BAR_PANEL = FIRST_SYSTEM_WINDOW+14;
/**
* Window type: secure system overlay windows, which need to be displayed
* on top of everything else. These windows must not take input
* focus, or they will interfere with the keyguard.
*
* This is exactly like {@link #TYPE_SYSTEM_OVERLAY} except that only the
* system itself is allowed to create these overlays. Applications cannot
* obtain permission to create secure system overlays.
* @hide
*/
public static final int TYPE_SECURE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+15;
/**
* End of types of system windows.
*/
public static final int LAST_SYSTEM_WINDOW = 2999;
/**
* Specifies what type of memory buffers should be used by this window.
* Default is normal.
*
* @see #MEMORY_TYPE_NORMAL
* @see #MEMORY_TYPE_PUSH_BUFFERS
*/
public int memoryType;
/** Memory type: The window's surface is allocated in main memory. */
public static final int MEMORY_TYPE_NORMAL = 0;
/** Memory type: The window's surface is configured to be accessible
* by DMA engines and hardware accelerators.
* @deprecated this is ignored, this value is set automatically when needed.
*/
@Deprecated
public static final int MEMORY_TYPE_HARDWARE = 1;
/** Memory type: The window's surface is configured to be accessible
* by graphics accelerators.
* @deprecated this is ignored, this value is set automatically when needed.
*/
@Deprecated
public static final int MEMORY_TYPE_GPU = 2;
/** Memory type: The window's surface doesn't own its buffers and
* therefore cannot be locked. Instead the buffers are pushed to
* it through native binder calls. */
public static final int MEMORY_TYPE_PUSH_BUFFERS = 3;
public int flags;
/**
* Window flag: as long as this window is visible to the user, allow the
* lock screen to activate while the screen is on. This can be used
* independently, or in combination with {@link #FLAG_KEEP_SCREEN_ON}
* and/or {@link #FLAG_SHOW_WHEN_LOCKED}
*/
public static final int FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001;
/**
* Window flag: everything behind this window will be dimmed. Use
* {@link #dimAmount} to control the amount of dim.
*/
public static final int FLAG_DIM_BEHIND = 0x00000002;
/** Window flag: blur everything behind this window. */
public static final int FLAG_BLUR_BEHIND = 0x00000004;
/**
* Window flag: this window won't ever get key input focus, so the user
* can not send key or other button events to it. Those will instead go
* to whatever focusable window is behind it. This flag will also enable
* {@link #FLAG_NOT_TOUCH_MODAL} whether or not that is explicitly set.
*
* <p>
* Setting this flag also implies that the window will not need to
* interact with a soft input method, so it will be Z-ordered and
* positioned independently of any active input method (typically this
* means it gets Z-ordered on top of the input method, so it can use the
* full screen for its content and cover the input method if needed. You
* can use {@link #FLAG_ALT_FOCUSABLE_IM} to modify this behavior.
*/
public static final int FLAG_NOT_FOCUSABLE = 0x00000008;
/** Window flag: this window can never receive touch events. */
public static final int FLAG_NOT_TOUCHABLE = 0x00000010;
/**
* Window flag: Even when this window is focusable (its
* {@link #FLAG_NOT_FOCUSABLE is not set), allow any pointer events
* outside of the window to be sent to the windows behind it. Otherwise
* it will consume all pointer events itself, regardless of whether they
* are inside of the window.
*/
public static final int FLAG_NOT_TOUCH_MODAL = 0x00000020;
/**
* Window flag: When set, if the device is asleep when the touch screen
* is pressed, you will receive this first touch event. Usually the
* first touch event is consumed by the system since the user can not
* see what they are pressing on.
*/
public static final int FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040;
/**
* Window flag: as long as this window is visible to the user, keep the
* device's screen turned on and bright.
*/
public static final int FLAG_KEEP_SCREEN_ON = 0x00000080;
/**
* Window flag: place the window within the entire screen, ignoring
* decorations around the border (a.k.a. the status bar). The window
* must correctly position its contents to take the screen decoration
* into account. This flag is normally set for you by Window as
* described in {@link Window#setFlags}.
*/
public static final int FLAG_LAYOUT_IN_SCREEN = 0x00000100;
/** Window flag: allow window to extend outside of the screen. */
public static final int FLAG_LAYOUT_NO_LIMITS = 0x00000200;
/**
* Window flag: Hide all screen decorations (e.g. status bar) while this
* window is displayed. This allows the window to use the entire display
* space for itself -- the status bar will be hidden when an app window
* with this flag set is on the top layer.
*/
public static final int FLAG_FULLSCREEN = 0x00000400;
/**
* Window flag: Override {@link #FLAG_FULLSCREEN and force the screen
* decorations (such as status bar) to be shown.
*/
public static final int FLAG_FORCE_NOT_FULLSCREEN = 0x00000800;
/**
* Window flag: turn on dithering when compositing this window to the
* screen.
*/
public static final int FLAG_DITHER = 0x00001000;
/**
* Window flag: don't allow screen shots while this window is displayed.
*/
public static final int FLAG_SECURE = 0x00002000;
/**
* Window flag: a special mode where the layout parameters are used to
* perform scaling of the surface when it is composited to the screen.
*/
public static final int FLAG_SCALED = 0x00004000;
/**
* Window flag: intended for windows that will often be used when the
* user is holding the screen against their face, it will aggressively
* filter the event stream to prevent unintended presses in this
* situation that may not be desired for a particular window, when such
* an event stream is detected, the application will receive a CANCEL
* motion event to indicate this so applications can handle this
* accordingly by taking no action on the event until the finger is
* released.
*/
public static final int FLAG_IGNORE_CHEEK_PRESSES = 0x00008000;
/**
* Window flag: a special option only for use in combination with
* {@link #FLAG_LAYOUT_IN_SCREEN}. When requesting layout in the screen
* your window may appear on top of or behind screen decorations such as
* the status bar. By also including this flag, the window manager will
* report the inset rectangle needed to ensure your content is not
* covered by screen decorations. This flag is normally set for you by
* Window as described in {@link Window#setFlags}.
*/
public static final int FLAG_LAYOUT_INSET_DECOR = 0x00010000;
/**
* Window flag: invert the state of {@link #FLAG_NOT_FOCUSABLE} with
* respect to how this window interacts with the current method. That
* is, if FLAG_NOT_FOCUSABLE is set and this flag is set, then the
* window will behave as if it needs to interact with the input method
* and thus be placed behind/away from it; if FLAG_NOT_FOCUSABLE is not
* set and this flag is set, then the window will behave as if it
* doesn't need to interact with the input method and can be placed to
* use more space and cover the input method.
*/
public static final int FLAG_ALT_FOCUSABLE_IM = 0x00020000;
/**
* Window flag: if you have set {@link #FLAG_NOT_TOUCH_MODAL}, you can
* set this flag to receive a single special MotionEvent with the action
* {@link MotionEvent#ACTION_OUTSIDE MotionEvent.ACTION_OUTSIDE} for
* touches that occur outside of your window. Note that you will not
* receive the full down/move/up gesture, only the location of the first
* down as an ACTION_OUTSIDE.
*/
public static final int FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000;
/**
* Window flag: special flag to let windows be shown when the screen is
* locked. This will let application windows take precedence over key
* guard or any other lock screens. Can be used with
* {@link #FLAG_KEEP_SCREEN_ON} to turn screen on and display windows
* directly before showing the key guard window. Can be used with
* {@link #FLAG_DISMISS_KEYGUARD} to automatically fully dismisss
* non-secure keyguards. This flag only applies to the top-most
* full-screen window.
*/
public static final int FLAG_SHOW_WHEN_LOCKED = 0x00080000;
/**
* Window flag: ask that the system wallpaper be shown behind your
* window. The window surface must be translucent to be able to actually
* see the wallpaper behind it; this flag just ensures that the
* wallpaper surface will be there if this window actually has
* translucent regions.
*/
public static final int FLAG_SHOW_WALLPAPER = 0x00100000;
/**
* Window flag: when set as a window is being added or made visible,
* once the window has been shown then the system will poke the power
* manager's user activity (as if the user had woken up the device) to
* turn the screen on.
*/
public static final int FLAG_TURN_SCREEN_ON = 0x00200000;
/**
* Window flag: when set the window will cause the keyguard to be
* dismissed, only if it is not a secure lock keyguard. Because such a
* keyguard is not needed for security, it will never re-appear if the
* user navigates to another window (in contrast to
* {@link #FLAG_SHOW_WHEN_LOCKED}, which will only temporarily hide both
* secure and non-secure keyguards but ensure they reappear when the
* user moves to another UI that doesn't hide them). If the keyguard is
* currently active and is secure (requires an unlock pattern) than the
* user will still need to confirm it before seeing this window, unless
* {@link #FLAG_SHOW_WHEN_LOCKED} has also been set.
*/
public static final int FLAG_DISMISS_KEYGUARD = 0x00400000;
/**
* Window flag: when set the window will accept for touch events outside
* of its bounds to be sent to other windows that also support split
* touch. When this flag is not set, the first pointer that goes down
* determines the window to which all subsequent touches go until all
* pointers go up. When this flag is set, each pointer (not necessarily
* the first) that goes down determines the window to which all
* subsequent touches of that pointer will go until that pointer goes up
* thereby enabling touches with multiple pointers to be split across
* multiple windows.
*
* {@hide}
*/
public static final int FLAG_SPLIT_TOUCH = 0x00800000;
/**
* Window flag: *sigh* The lock screen wants to continue running its
* animation while it is fading. A kind-of hack to allow this. Maybe in
* the future we just make this the default behavior.
*
* {@hide}
*/
public static final int FLAG_KEEP_SURFACE_WHILE_ANIMATING = 0x10000000;
/**
* Window flag: special flag to limit the size of the window to be
* original size ([320x480] x density). Used to create window for
* applications running under compatibility mode.
*
* {@hide}
*/
public static final int FLAG_COMPATIBLE_WINDOW = 0x20000000;
/**
* Window flag: a special option intended for system dialogs. When this
* flag is set, the window will demand focus unconditionally when it is
* created. {@hide}
*/
public static final int FLAG_SYSTEM_ERROR = 0x40000000;
/**
* Given a particular set of window manager flags, determine whether
* such a window may be a target for an input method when it has focus.
* In particular, this checks the {@link #FLAG_NOT_FOCUSABLE} and
* {@link #FLAG_ALT_FOCUSABLE_IM} flags and returns true if the
* combination of the two corresponds to a window that needs to be
* behind the input method so that the user can type into it.
*
* @param flags
* The current window manager flags.
*
* @return Returns true if such a window should be behind/interact with
* an input method, false if not.
*/
public static boolean mayUseInputMethod(int flags) {
switch (flags & (FLAG_NOT_FOCUSABLE | FLAG_ALT_FOCUSABLE_IM)) {
case 0:
case FLAG_NOT_FOCUSABLE | FLAG_ALT_FOCUSABLE_IM:
return true;
}
return false;
}
/**
* Mask for {@link #softInputMode} of the bits that determine the
* desired visibility state of the soft input area for this window.
*/
public static final int SOFT_INPUT_MASK_STATE = 0x0f;
/**
* Visibility state for {@link #softInputMode}: no state has been
* specified.
*/
public static final int SOFT_INPUT_STATE_UNSPECIFIED = 0;
/**
* Visibility state for {@link #softInputMode}: please don't change the
* state of the soft input area.
*/
public static final int SOFT_INPUT_STATE_UNCHANGED = 1;
/**
* Visibility state for {@link #softInputMode}: please hide any soft
* input area when normally appropriate (when the user is navigating
* forward to your window).
*/
public static final int SOFT_INPUT_STATE_HIDDEN = 2;
/**
* Visibility state for {@link #softInputMode}: please always hide any
* soft input area when this window receives focus.
*/
public static final int SOFT_INPUT_STATE_ALWAYS_HIDDEN = 3;
/**
* Visibility state for {@link #softInputMode}: please show the soft
* input area when normally appropriate (when the user is navigating
* forward to your window).
*/
public static final int SOFT_INPUT_STATE_VISIBLE = 4;
/**
* Visibility state for {@link #softInputMode}: please always make the
* soft input area visible when this window receives input focus.
*/
public static final int SOFT_INPUT_STATE_ALWAYS_VISIBLE = 5;
/**
* Mask for {@link #softInputMode} of the bits that determine the way
* that the window should be adjusted to accommodate the soft input
* window.
*/
public static final int SOFT_INPUT_MASK_ADJUST = 0xf0;
/**
* Adjustment option for {@link #softInputMode}: nothing specified. The
* system will try to pick one or the other depending on the contents of
* the window.
*/
public static final int SOFT_INPUT_ADJUST_UNSPECIFIED = 0x00;
/**
* Adjustment option for {@link #softInputMode}: set to allow the window
* to be resized when an input method is shown, so that its contents are
* not covered by the input method. This can <em>not</em> be combined
* with {@link #SOFT_INPUT_ADJUST_PAN}; if neither of these are set,
* then the system will try to pick one or the other depending on the
* contents of the window.
*/
public static final int SOFT_INPUT_ADJUST_RESIZE = 0x10;
/**
* Adjustment option for {@link #softInputMode}: set to have a window
* pan when an input method is shown, so it doesn't need to deal with
* resizing but just panned by the framework to ensure the current input
* focus is visible. This can <em>not</em> be combined with
* {@link #SOFT_INPUT_ADJUST_RESIZE}; if neither of these are set, then
* the system will try to pick one or the other depending on the
* contents of the window.
*/
public static final int SOFT_INPUT_ADJUST_PAN = 0x20;
/**
* Bit for {@link #softInputMode}: set when the user has navigated
* forward to the window. This is normally set automatically for you by
* the system, though you may want to set it in certain cases when you
* are displaying a window yourself. This flag will always be cleared
* automatically after the window is displayed.
*/
public static final int SOFT_INPUT_IS_FORWARD_NAVIGATION = 0x100;
/**
* Default value for {@link #screenBrightness} and
* {@link #buttonBrightness} indicating that the brightness value is not
* overridden for this window and normal brightness policy should be
* used.
*/
public static final float BRIGHTNESS_OVERRIDE_NONE = -1.0f;
/**
* Value for {@link #screenBrightness} and {@link #buttonBrightness}
* indicating that the screen or button backlight brightness should be
* set to the lowest value when this window is in front.
*/
public static final float BRIGHTNESS_OVERRIDE_OFF = 0.0f;
/**
* Value for {@link #screenBrightness} and {@link #buttonBrightness}
* indicating that the screen or button backlight brightness should be
* set to the hightest value when this window is in front.
*/
public static final float BRIGHTNESS_OVERRIDE_FULL = 1.0f;
/**
* Desired operating mode for any soft input area. May any combination
* of:
*
* <ul>
* <li>One of the visibility states
* {@link #SOFT_INPUT_STATE_UNSPECIFIED},
* {@link #SOFT_INPUT_STATE_UNCHANGED}, {@link #SOFT_INPUT_STATE_HIDDEN}, {@link #SOFT_INPUT_STATE_ALWAYS_VISIBLE}, or
* {@link #SOFT_INPUT_STATE_VISIBLE}.
* <li>One of the adjustment options
* {@link #SOFT_INPUT_ADJUST_UNSPECIFIED},
* {@link #SOFT_INPUT_ADJUST_RESIZE}, or {@link #SOFT_INPUT_ADJUST_PAN}.
*/
public int softInputMode;
/**
* Placement of window within the screen as per {@link Gravity}
*
* @see Gravity
*/
public int gravity;
/**
* The horizontal margin, as a percentage of the container's width,
* between the container and the widget.
*/
public float horizontalMargin;
/**
* The vertical margin, as a percentage of the container's height,
* between the container and the widget.
*/
public float verticalMargin;
/**
* The desired bitmap format. May be one of the constants in
* {@link android.graphics.PixelFormat}. Default is OPAQUE.
*/
public int format;
/**
* A style resource defining the animations to use for this window. This
* must be a system resource; it can not be an application resource
* because the window manager does not have access to applications.
*/
public int windowAnimations;
/**
* An alpha value to apply to this entire window. An alpha of 1.0 means
* fully opaque and 0.0 means fully transparent
*/
public float alpha = 1.0f;
/**
* When {@link #FLAG_DIM_BEHIND} is set, this is the amount of dimming
* to apply. Range is from 1.0 for completely opaque to 0.0 for no dim.
*/
public float dimAmount = 1.0f;
/**
* This can be used to override the user's preferred brightness of the
* screen. A value of less than 0, the default, means to use the
* preferred screen brightness. 0 to 1 adjusts the brightness from dark
* to full bright.
*/
public float screenBrightness = BRIGHTNESS_OVERRIDE_NONE;
/**
* This can be used to override the standard behavior of the button and
* keyboard backlights. A value of less than 0, the default, means to
* use the standard backlight behavior. 0 to 1 adjusts the brightness
* from dark to full bright.
*/
public float buttonBrightness = BRIGHTNESS_OVERRIDE_NONE;
/**
* Name of the package owning this window.
*/
public String packageName = null;
/**
* Specific orientation value for a window. May be any of the same
* values allowed for
* {@link android.content.pm.ActivityInfo#screenOrientation}. If not
* set, a default value of
* {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED}
* will be used.
*/
public int screenOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
public LayoutParams() {
super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
type = TYPE_APPLICATION;
format = PixelFormat.OPAQUE;
}
public LayoutParams(int _type) {
super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
type = _type;
format = PixelFormat.OPAQUE;
}
public LayoutParams(int _type, int _flags) {
super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
type = _type;
flags = _flags;
format = PixelFormat.OPAQUE;
}
public LayoutParams(int _type, int _flags, int _format) {
super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
type = _type;
flags = _flags;
format = _format;
}
public LayoutParams(int w, int h, int _type, int _flags, int _format) {
super(w, h);
type = _type;
flags = _flags;
format = _format;
}
public LayoutParams(int w, int h, int xpos, int ypos, int _type,
int _flags, int _format) {
super(w, h);
x = xpos;
y = ypos;
type = _type;
flags = _flags;
format = _format;
}
public final void setTitle(CharSequence title) {
if (null == title)
title = "";
mTitle = title;
}
public final CharSequence getTitle() {
return mTitle;
}
public int describeContents() {
return 0;
}
public static final int LAYOUT_CHANGED = 1 << 0;
public static final int TYPE_CHANGED = 1 << 1;
public static final int FLAGS_CHANGED = 1 << 2;
public static final int FORMAT_CHANGED = 1 << 3;
public static final int ANIMATION_CHANGED = 1 << 4;
public static final int DIM_AMOUNT_CHANGED = 1 << 5;
public static final int TITLE_CHANGED = 1 << 6;
public static final int ALPHA_CHANGED = 1 << 7;
public static final int MEMORY_TYPE_CHANGED = 1 << 8;
public static final int SOFT_INPUT_MODE_CHANGED = 1 << 9;
public static final int SCREEN_ORIENTATION_CHANGED = 1 << 10;
public static final int SCREEN_BRIGHTNESS_CHANGED = 1 << 11;
/** {@hide} */
public static final int BUTTON_BRIGHTNESS_CHANGED = 1 << 12;
// internal buffer to backup/restore parameters under compatibility
// mode.
private int[] mCompatibilityParamsBackup = null;
public final int copyFrom(LayoutParams o) {
int changes = 0;
if (width != o.width) {
width = o.width;
changes |= LAYOUT_CHANGED;
}
if (height != o.height) {
height = o.height;
changes |= LAYOUT_CHANGED;
}
if (x != o.x) {
x = o.x;
changes |= LAYOUT_CHANGED;
}
if (y != o.y) {
y = o.y;
changes |= LAYOUT_CHANGED;
}
if (horizontalWeight != o.horizontalWeight) {
horizontalWeight = o.horizontalWeight;
changes |= LAYOUT_CHANGED;
}
if (verticalWeight != o.verticalWeight) {
verticalWeight = o.verticalWeight;
changes |= LAYOUT_CHANGED;
}
if (horizontalMargin != o.horizontalMargin) {
horizontalMargin = o.horizontalMargin;
changes |= LAYOUT_CHANGED;
}
if (verticalMargin != o.verticalMargin) {
verticalMargin = o.verticalMargin;
changes |= LAYOUT_CHANGED;
}
if (type != o.type) {
type = o.type;
changes |= TYPE_CHANGED;
}
if (memoryType != o.memoryType) {
memoryType = o.memoryType;
changes |= MEMORY_TYPE_CHANGED;
}
if (flags != o.flags) {
flags = o.flags;
changes |= FLAGS_CHANGED;
}
if (softInputMode != o.softInputMode) {
softInputMode = o.softInputMode;
changes |= SOFT_INPUT_MODE_CHANGED;
}
if (gravity != o.gravity) {
gravity = o.gravity;
changes |= LAYOUT_CHANGED;
}
if (horizontalMargin != o.horizontalMargin) {
horizontalMargin = o.horizontalMargin;
changes |= LAYOUT_CHANGED;
}
if (verticalMargin != o.verticalMargin) {
verticalMargin = o.verticalMargin;
changes |= LAYOUT_CHANGED;
}
if (format != o.format) {
format = o.format;
changes |= FORMAT_CHANGED;
}
if (windowAnimations != o.windowAnimations) {
windowAnimations = o.windowAnimations;
changes |= ANIMATION_CHANGED;
}
if (packageName == null) {
// NOTE: packageName only copied if the recipient doesn't
// already have one.
packageName = o.packageName;
}
if (!mTitle.equals(o.mTitle)) {
mTitle = o.mTitle;
changes |= TITLE_CHANGED;
}
if (alpha != o.alpha) {
alpha = o.alpha;
changes |= ALPHA_CHANGED;
}
if (dimAmount != o.dimAmount) {
dimAmount = o.dimAmount;
changes |= DIM_AMOUNT_CHANGED;
}
if (screenBrightness != o.screenBrightness) {
screenBrightness = o.screenBrightness;
changes |= SCREEN_BRIGHTNESS_CHANGED;
}
if (buttonBrightness != o.buttonBrightness) {
buttonBrightness = o.buttonBrightness;
changes |= BUTTON_BRIGHTNESS_CHANGED;
}
if (screenOrientation != o.screenOrientation) {
screenOrientation = o.screenOrientation;
changes |= SCREEN_ORIENTATION_CHANGED;
}
return changes;
}
@Override
public String debug(String output) {
output += "Contents of " + this + ":";
Log.d("Debug", output);
output = super.debug("");
Log.d("Debug", output);
Log.d("Debug", "");
Log.d("Debug", "Window.LayoutParams={title=" + mTitle + "}");
return "";
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(256);
sb.append("WM.LayoutParams{");
sb.append("(");
sb.append(x);
sb.append(',');
sb.append(y);
sb.append(")(");
sb.append((width == MATCH_PARENT ? "fill"
: (width == WRAP_CONTENT ? "wrap" : width)));
sb.append('x');
sb.append((height == MATCH_PARENT ? "fill"
: (height == WRAP_CONTENT ? "wrap" : height)));
sb.append(")");
if (softInputMode != 0) {
sb.append(" sim=#");
sb.append(Integer.toHexString(softInputMode));
}
if (gravity != 0) {
sb.append(" gr=#");
sb.append(Integer.toHexString(gravity));
}
sb.append(" ty=");
sb.append(type);
sb.append(" fl=#");
sb.append(Integer.toHexString(flags));
sb.append(" fmt=");
sb.append(format);
if (windowAnimations != 0) {
sb.append(" wanim=0x");
sb.append(Integer.toHexString(windowAnimations));
}
if (screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
sb.append(" or=");
sb.append(screenOrientation);
}
if ((flags & FLAG_COMPATIBLE_WINDOW) != 0) {
sb.append(" compatible=true");
}
sb.append('}');
return sb.toString();
}
/**
* Scale the layout params' coordinates and size.
*
* @hide
*/
public void scale(float scale) {
x = (int) (x * scale + 0.5f);
y = (int) (y * scale + 0.5f);
if (width > 0) {
width = (int) (width * scale + 0.5f);
}
if (height > 0) {
height = (int) (height * scale + 0.5f);
}
}
/**
* Backup the layout parameters used in compatibility mode.
*
* @see LayoutParams#restore()
*/
void backup() {
int[] backup = mCompatibilityParamsBackup;
if (backup == null) {
// we backup 4 elements, x, y, width, height
backup = mCompatibilityParamsBackup = new int[4];
}
backup[0] = x;
backup[1] = y;
backup[2] = width;
backup[3] = height;
}
/**
* Restore the layout params' coordinates, size and gravity
*
* @see LayoutParams#backup()
*/
void restore() {
int[] backup = mCompatibilityParamsBackup;
if (backup != null) {
x = backup[0];
y = backup[1];
width = backup[2];
height = backup[3];
}
}
private CharSequence mTitle = "";
public IBinder token = null;
}
public void addView(View view, android.view.ViewGroup.LayoutParams params) {
}
public void updateViewLayout(View view,
android.view.ViewGroup.LayoutParams params) {
}
public void removeView(View view) {
}
public Display getDefaultDisplay() {
return new Display(Display.DEFAULT_DISPLAY);
}
public void removeViewImmediate(View view) {
}
}