Android：窗口WindowManager---翻譯

WindowManager.LayoutParams的設置參數
使用WindowManager.LayoutParams的x和y設置窗體位置
窗體的大小和位置通過WindowManager.LayoutParams來設置，在通過x和y值來設置窗體位置時，需要注意gravity屬性，如果gravity沒有設置或者是center之類的，那麼設置的x和y值就不會起作用，具體的說明見

X position for this window. With the default gravity it is ignored. When using LEFT or START or RIGHT or END it provides an offset from the given edge.
Y position for this window. With the default gravity it is ignored. When using TOP or BOTTOM it provides an offset from the given edge.

WindowManager類
/*

• Copyright © 2006 The Android Open Source Project
• Licensed under the Apache License, Version 2.0 (the “License”);
• you may not use this file except in compliance with the License.
• You may obtain a copy of the License at
• http://www.apache.org/licenses/LICENSE-2.0
• Unless required by applicable law or agreed to in writing, software
• distributed under the License is distributed on an “AS IS” BASIS,
• WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
• See the License for the specific language governing permissions and
• limitations under the License.
  /
  package android.view;
  import android.Manifest.permission;
  import android.annotation.IntDef;
  import android.annotation.NonNull;
  import android.annotation.RequiresPermission;
  import android.annotation.SystemApi;
  import android.annotation.SystemService;
  import android.annotation.TestApi;
  import android.app.KeyguardManager;
  import android.app.Presentation;
  import android.content.Context;
  import android.content.pm.ActivityInfo;
  import android.graphics.PixelFormat;
  import android.graphics.Rect;
  import android.graphics.Region;
  import android.os.IBinder;
  import android.os.Parcel;
  import android.os.Parcelable;
  import android.text.TextUtils;
  import android.util.Log;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.util.List;
  import java.util.Objects;
  /*
• The interface that apps use to talk to the window manager.
• Each window manager instance is bound to a particular {@link Display}.
• To obtain a {@link WindowManager} for a different display, use
• {@link Context#createDisplayContext} to obtain a {@link Context} for that
• display, then use Context.getSystemService(Context.WINDOW_SERVICE)
• to get the WindowManager.
• The simplest way to show a window on another display is to create a
• {@link Presentation}. The presentation will automatically obtain a
• {@link WindowManager} and {@link Context} for that display.

/
@SystemService(Context.WINDOW_SERVICE)
public interface WindowManager extends ViewManager {
/* @hide /
int DOCKED_INVALID = -1;
/* @hide /
int DOCKED_LEFT = 1;
/* @hide /
int DOCKED_TOP = 2;
/* @hide /
int DOCKED_RIGHT = 3;
/* @hide /
int DOCKED_BOTTOM = 4;
/* @hide /
final static String INPUT_CONSUMER_PIP = “pip_input_consumer”;
/* @hide /
final static String INPUT_CONSUMER_NAVIGATION = “nav_input_consumer”;
/* @hide /
final static String INPUT_CONSUMER_WALLPAPER = “wallpaper_input_consumer”;
/*

• Exception that is thrown when trying to add view whose
• {@link LayoutParams} {@link LayoutParams#token}
• is invalid.
  /
  public static class BadTokenException extends RuntimeException {
  public BadTokenException() {
  }
  public BadTokenException(String name) {
  super(name);
  }
  }
  /*
• Exception that is thrown when calling {@link #addView} to a secondary display that cannot
• be found. See {@link android.app.Presentation} for more information on secondary displays.
  /
  public static class InvalidDisplayException extends RuntimeException {
  public InvalidDisplayException() {
  }
  public InvalidDisplayException(String name) {
  super(name);
  }
  }
  /*
• Returns the {@link Display} upon which this {@link WindowManager} instance
• will create new windows.
• Despite the name of this method, the display that is returned is not
• necessarily the primary display of the system (see {@link Display#DEFAULT_DISPLAY}).
• The returned display could instead be a secondary display that this
• window manager instance is managing. Think of it as the display that
• this {@link WindowManager} instance uses by default.
• To create windows on a different display, you need to obtain a
• {@link WindowManager} for that {@link Display}. (See the {@link WindowManager}
• class documentation for more information.)
• @return The display that this window manager is managing.
  /
  public Display getDefaultDisplay();
  /*
• Special variation of {@link #removeView} that immediately invokes
• the given view hierarchy’s {@link View#onDetachedFromWindow()
• View.onDetachedFromWindow()} methods before returning. This is not
• for normal applications; using it correctly requires great care.
• @param view The view to be removed.
  /
  public void removeViewImmediate(View view);
  /*
• Used to asynchronously request Keyboard Shortcuts from the focused window.
• @hide
  /
  public interface KeyboardShortcutsReceiver {
  /*
• Callback used when the focused window keyboard shortcuts are ready to be displayed.
• @param result The keyboard shortcuts to be displayed.
  /
  void onKeyboardShortcutsReceived(List result);
  }
  /*
• Message for taking fullscreen screenshot
• @hide
  /
  final int TAKE_SCREENSHOT_FULLSCREEN = 1;
  /*
• Message for taking screenshot of selected region.
• @hide
  /
  final int TAKE_SCREENSHOT_SELECTED_REGION = 2;
  /*
• @hide
  /
  public static final String PARCEL_KEY_SHORTCUTS_ARRAY = “shortcuts_array”;
  /*
• Request for keyboard shortcuts to be retrieved asynchronously.
• @param receiver The callback to be triggered when the result is ready.
• @hide
  /
  public void requestAppKeyboardShortcuts(final KeyboardShortcutsReceiver receiver, int deviceId);
  /*
• Return the touch region for the current IME window, or an empty region if there is none.
• @return The region of the IME that is accepting touch inputs, or null if there is no IME, no
• region or there was an error.
• @hide
  /
  @SystemApi
  @RequiresPermission(android.Manifest.permission.RESTRICTED_VR_ACCESS)
  public Region getCurrentImeTouchRegion();
  public static class LayoutParams extends ViewGroup.LayoutParams implements Parcelable {
  /*
• X position for this window. With the default gravity it is ignored.
• When using {@link Gravity#LEFT} or {@link Gravity#START} or {@link Gravity#RIGHT} or
• {@link Gravity#END} it provides an offset from the given edge.
  /
  @ViewDebug.ExportedProperty
  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.
  /
  @ViewDebug.ExportedProperty
  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.
  /
  @ViewDebug.ExportedProperty
  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.
  /
  @ViewDebug.ExportedProperty
  public float verticalWeight;
  /*
• The general type of window. There are three main classes of
• window types:
• Application windows (ranging from
• {@link #FIRST_APPLICATION_WINDOW} to
• {@link #LAST_APPLICATION_WINDOW}) are normal top-level application
• windows. For these types of windows, the {@link #token} must be
• set to the token of the activity they are a part of (this will
• normally be done for you if {@link #token} is null).
• Sub-windows (ranging from
• {@link #FIRST_SUB_WINDOW} to
• {@link #LAST_SUB_WINDOW}) are associated with another top-level
• window. For these types of windows, the {@link #token} must be
• the token of the window it is attached to.
• System windows (ranging from
• {@link #FIRST_SYSTEM_WINDOW} to
• {@link #LAST_SYSTEM_WINDOW}) are special types of windows for
• use by the system for specific purposes. They should not normally
• be used by applications, and a special permission is required
• to use them.

@see #TYPE_BASE_APPLICATION

@see #TYPE_APPLICATION

@see #TYPE_APPLICATION_STARTING

@see #TYPE_DRAWN_APPLICATION

@see #TYPE_APPLICATION_PANEL

@see #TYPE_APPLICATION_MEDIA

@see #TYPE_APPLICATION_SUB_PANEL

@see #TYPE_APPLICATION_ABOVE_SUB_PANEL

@see #TYPE_APPLICATION_ATTACHED_DIALOG

@see #TYPE_STATUS_BAR

@see #TYPE_SEARCH_BAR

@see #TYPE_PHONE

@see #TYPE_SYSTEM_ALERT

@see #TYPE_TOAST

@see #TYPE_SYSTEM_OVERLAY

@see #TYPE_PRIORITY_PHONE

@see #TYPE_STATUS_BAR_PANEL

@see #TYPE_SYSTEM_DIALOG

@see #TYPE_KEYGUARD_DIALOG

@see #TYPE_SYSTEM_ERROR

@see #TYPE_INPUT_METHOD

@see #TYPE_INPUT_METHOD_DIALOG
/
@ViewDebug.ExportedProperty(mapping = {
@ViewDebug.IntToString(from = TYPE_BASE_APPLICATION,
to = “TYPE_BASE_APPLICATION”),
@ViewDebug.IntToString(from = TYPE_APPLICATION,
to = “TYPE_APPLICATION”),
@ViewDebug.IntToString(from = TYPE_APPLICATION_STARTING,
to = “TYPE_APPLICATION_STARTING”),
@ViewDebug.IntToString(from = TYPE_DRAWN_APPLICATION,
to = “TYPE_DRAWN_APPLICATION”),
@ViewDebug.IntToString(from = TYPE_APPLICATION_PANEL,
to = “TYPE_APPLICATION_PANEL”),
@ViewDebug.IntToString(from = TYPE_APPLICATION_MEDIA,
to = “TYPE_APPLICATION_MEDIA”),
@ViewDebug.IntToString(from = TYPE_APPLICATION_SUB_PANEL,
to = “TYPE_APPLICATION_SUB_PANEL”),
@ViewDebug.IntToString(from = TYPE_APPLICATION_ABOVE_SUB_PANEL,
to = “TYPE_APPLICATION_ABOVE_SUB_PANEL”),
@ViewDebug.IntToString(from = TYPE_APPLICATION_ATTACHED_DIALOG,
to = “TYPE_APPLICATION_ATTACHED_DIALOG”),
@ViewDebug.IntToString(from = TYPE_APPLICATION_MEDIA_OVERLAY,
to = “TYPE_APPLICATION_MEDIA_OVERLAY”),
@ViewDebug.IntToString(from = TYPE_STATUS_BAR,
to = “TYPE_STATUS_BAR”),
@ViewDebug.IntToString(from = TYPE_SEARCH_BAR,
to = “TYPE_SEARCH_BAR”),
@ViewDebug.IntToString(from = TYPE_PHONE,
to = “TYPE_PHONE”),
@ViewDebug.IntToString(from = TYPE_SYSTEM_ALERT,
to = “TYPE_SYSTEM_ALERT”),
@ViewDebug.IntToString(from = TYPE_TOAST,
to = “TYPE_TOAST”),
@ViewDebug.IntToString(from = TYPE_SYSTEM_OVERLAY,
to = “TYPE_SYSTEM_OVERLAY”),
@ViewDebug.IntToString(from = TYPE_PRIORITY_PHONE,
to = “TYPE_PRIORITY_PHONE”),
@ViewDebug.IntToString(from = TYPE_SYSTEM_DIALOG,
to = “TYPE_SYSTEM_DIALOG”),
@ViewDebug.IntToString(from = TYPE_KEYGUARD_DIALOG,
to = “TYPE_KEYGUARD_DIALOG”),
@ViewDebug.IntToString(from = TYPE_SYSTEM_ERROR,
to = “TYPE_SYSTEM_ERROR”),
@ViewDebug.IntToString(from = TYPE_INPUT_METHOD,
to = “TYPE_INPUT_METHOD”),
@ViewDebug.IntToString(from = TYPE_INPUT_METHOD_DIALOG,
to = “TYPE_INPUT_METHOD_DIALOG”),
@ViewDebug.IntToString(from = TYPE_WALLPAPER,
to = “TYPE_WALLPAPER”),
@ViewDebug.IntToString(from = TYPE_STATUS_BAR_PANEL,
to = “TYPE_STATUS_BAR_PANEL”),
@ViewDebug.IntToString(from = TYPE_SECURE_SYSTEM_OVERLAY,
to = “TYPE_SECURE_SYSTEM_OVERLAY”),
@ViewDebug.IntToString(from = TYPE_DRAG,
to = “TYPE_DRAG”),
@ViewDebug.IntToString(from = TYPE_STATUS_BAR_SUB_PANEL,
to = “TYPE_STATUS_BAR_SUB_PANEL”),
@ViewDebug.IntToString(from = TYPE_POINTER,
to = “TYPE_POINTER”),
@ViewDebug.IntToString(from = TYPE_NAVIGATION_BAR,
to = “TYPE_NAVIGATION_BAR”),
@ViewDebug.IntToString(from = TYPE_VOLUME_OVERLAY,
to = “TYPE_VOLUME_OVERLAY”),
@ViewDebug.IntToString(from = TYPE_BOOT_PROGRESS,
to = “TYPE_BOOT_PROGRESS”),
@ViewDebug.IntToString(from = TYPE_INPUT_CONSUMER,
to = “TYPE_INPUT_CONSUMER”),
@ViewDebug.IntToString(from = TYPE_DREAM,
to = “TYPE_DREAM”),
@ViewDebug.IntToString(from = TYPE_NAVIGATION_BAR_PANEL,
to = “TYPE_NAVIGATION_BAR_PANEL”),
@ViewDebug.IntToString(from = TYPE_DISPLAY_OVERLAY,
to = “TYPE_DISPLAY_OVERLAY”),
@ViewDebug.IntToString(from = TYPE_MAGNIFICATION_OVERLAY,
to = “TYPE_MAGNIFICATION_OVERLAY”),
@ViewDebug.IntToString(from = TYPE_PRESENTATION,
to = “TYPE_PRESENTATION”),
@ViewDebug.IntToString(from = TYPE_PRIVATE_PRESENTATION,
to = “TYPE_PRIVATE_PRESENTATION”),
@ViewDebug.IntToString(from = TYPE_VOICE_INTERACTION,
to = “TYPE_VOICE_INTERACTION”),
@ViewDebug.IntToString(from = TYPE_VOICE_INTERACTION_STARTING,
to = “TYPE_VOICE_INTERACTION_STARTING”),
@ViewDebug.IntToString(from = TYPE_DOCK_DIVIDER,
to = “TYPE_DOCK_DIVIDER”),
@ViewDebug.IntToString(from = TYPE_QS_DIALOG,
to = “TYPE_QS_DIALOG”),
@ViewDebug.IntToString(from = TYPE_SCREENSHOT,
to = “TYPE_SCREENSHOT”),
@ViewDebug.IntToString(from = TYPE_APPLICATION_OVERLAY,
to = “TYPE_APPLICATION_OVERLAY”)
})
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.

In multiuser systems shows only on the owning user’s window.
/
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.

In multiuser systems shows only on the owning user’s window.
/
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.

In multiuser systems shows on all users’ windows.
/
public static final int TYPE_APPLICATION_STARTING = 3;
/*

Window type: a variation on TYPE_APPLICATION that ensures the window

manager will wait for this window to be drawn before the app is shown.

In multiuser systems shows only on the owning user’s window.
/
public static final int TYPE_DRAWN_APPLICATION = 4;
/*

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 (such as 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, not

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;
/*

Window type: a above sub-panel on top of an application window and it’s

sub-panel windows. These windows are displayed on top of their attached window

and any {@link #TYPE_APPLICATION_SUB_PANEL} panels.

@hide
/
public static final int TYPE_APPLICATION_ABOVE_SUB_PANEL = FIRST_SUB_WINDOW + 5;
/*

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.

In multiuser systems shows on all users’ windows.
/
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.

In multiuser systems shows on all users’ windows.
/
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.

In multiuser systems shows on all users’ windows.

@deprecated for non-system apps. Use {@link #TYPE_APPLICATION_OVERLAY} instead.
/
@Deprecated
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.

In multiuser systems shows only on the owning user’s window.

@deprecated for non-system apps. Use {@link #TYPE_APPLICATION_OVERLAY} instead.
/
@Deprecated
public static final int TYPE_SYSTEM_ALERT = FIRST_SYSTEM_WINDOW+3;
/*

Window type: keyguard window.

In multiuser systems shows on all users’ windows.

@removed
/
public static final int TYPE_KEYGUARD = FIRST_SYSTEM_WINDOW+4;
/*

Window type: transient notifications.

In multiuser systems shows only on the owning user’s window.

@deprecated for non-system apps. Use {@link #TYPE_APPLICATION_OVERLAY} instead.
/
@Deprecated
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.

In multiuser systems shows only on the owning user’s window.

@deprecated for non-system apps. Use {@link #TYPE_APPLICATION_OVERLAY} instead.
/
@Deprecated
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.

In multiuser systems shows on all users’ windows.

@deprecated for non-system apps. Use {@link #TYPE_APPLICATION_OVERLAY} instead.
/
@Deprecated
public static final int TYPE_PRIORITY_PHONE = FIRST_SYSTEM_WINDOW+7;
/*

Window type: panel that slides out from the status bar

In multiuser systems shows on all users’ windows.
/
public static final int TYPE_SYSTEM_DIALOG = FIRST_SYSTEM_WINDOW+8;
/*

Window type: dialogs that the keyguard shows

In multiuser systems shows on all users’ windows.
/
public static final int TYPE_KEYGUARD_DIALOG = FIRST_SYSTEM_WINDOW+9;
/*

Window type: internal system error windows, appear on top of

everything they can.

In multiuser systems shows only on the owning user’s window.

@deprecated for non-system apps. Use {@link #TYPE_APPLICATION_OVERLAY} instead.
/
@Deprecated
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.

In multiuser systems shows only on the owning user’s window.
/
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.

In multiuser systems shows only on the owning user’s 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.

In multiuser systems shows only on the owning user’s window.
/
public static final int TYPE_WALLPAPER = FIRST_SYSTEM_WINDOW+13;
/*

Window type: panel that slides out from over the status bar

In multiuser systems shows on all users’ windows.
/
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.

In multiuser systems shows only on the owning user’s window.

@hide
/
public static final int TYPE_SECURE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+15;
/*

Window type: the drag-and-drop pseudowindow. There is only one

drag layer (at most), and it is placed on top of all other windows.

In multiuser systems shows only on the owning user’s window.

@hide
/
public static final int TYPE_DRAG = FIRST_SYSTEM_WINDOW+16;
/*

Window type: panel that slides out from under the status bar

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_STATUS_BAR_SUB_PANEL = FIRST_SYSTEM_WINDOW+17;
/*

Window type: (mouse) pointer

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_POINTER = FIRST_SYSTEM_WINDOW+18;
/*

Window type: Navigation bar (when distinct from status bar)

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_NAVIGATION_BAR = FIRST_SYSTEM_WINDOW+19;
/*

Window type: The volume level overlay/dialog shown when the user

changes the system volume.

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_VOLUME_OVERLAY = FIRST_SYSTEM_WINDOW+20;
/*

Window type: The boot progress dialog, goes on top of everything

in the world.

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_BOOT_PROGRESS = FIRST_SYSTEM_WINDOW+21;
/*

Window type to consume input events when the systemUI bars are hidden.

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_INPUT_CONSUMER = FIRST_SYSTEM_WINDOW+22;
/*

Window type: Dreams (screen saver) window, just above keyguard.

In multiuser systems shows only on the owning user’s window.

@hide
/
public static final int TYPE_DREAM = FIRST_SYSTEM_WINDOW+23;
/*

Window type: Navigation bar panel (when navigation bar is distinct from status bar)

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_NAVIGATION_BAR_PANEL = FIRST_SYSTEM_WINDOW+24;
/*

Window type: Display overlay window. Used to simulate secondary display devices.

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_DISPLAY_OVERLAY = FIRST_SYSTEM_WINDOW+26;
/*

Window type: Magnification overlay window. Used to highlight the magnified

portion of a display when accessibility magnification is enabled.

In multiuser systems shows on all users’ windows.

@hide
/
public static final int TYPE_MAGNIFICATION_OVERLAY = FIRST_SYSTEM_WINDOW+27;
/*

Window type: Window for Presentation on top of private

virtual display.
/
public static final int TYPE_PRIVATE_PRESENTATION = FIRST_SYSTEM_WINDOW+30;
/*

Window type: Windows in the voice interaction layer.

@hide
/
public static final int TYPE_VOICE_INTERACTION = FIRST_SYSTEM_WINDOW+31;
/*

Window type: Windows that are overlaid only by a connected {@link

android.accessibilityservice.AccessibilityService} for interception of

user interactions without changing the windows an accessibility service

can introspect. In particular, an accessibility service can introspect

only windows that a sighted user can interact with which is they can touch

these windows or can type into these windows. For example, if there

is a full screen accessibility overlay that is touchable, the windows

below it will be introspectable by an accessibility service even though

they are covered by a touchable window.
/
public static final int TYPE_ACCESSIBILITY_OVERLAY = FIRST_SYSTEM_WINDOW+32;
/*

Window type: Starting window for voice interaction layer.

@hide
/
public static final int TYPE_VOICE_INTERACTION_STARTING = FIRST_SYSTEM_WINDOW+33;
/*

Window for displaying a handle used for resizing docked stacks. This window is owned

by the system process.

@hide
/
public static final int TYPE_DOCK_DIVIDER = FIRST_SYSTEM_WINDOW+34;
/*

Window type: like {@link #TYPE_APPLICATION_ATTACHED_DIALOG}, but used

by Quick Settings Tiles.

@hide
/
public static final int TYPE_QS_DIALOG = FIRST_SYSTEM_WINDOW+35;
/*

Window type: shares similar characteristics with {@link #TYPE_DREAM}. The layer is

reserved for screenshot region selection. These windows must not take input focus.

@hide
/
public static final int TYPE_SCREENSHOT = FIRST_SYSTEM_WINDOW + 36;
/*

Window type: Window for Presentation on an external display.

@see android.app.Presentation

@hide
/
public static final int TYPE_PRESENTATION = FIRST_SYSTEM_WINDOW + 37;
/*

Window type: Application overlay windows are displayed above all activity windows

(types between {@link #FIRST_APPLICATION_WINDOW} and {@link #LAST_APPLICATION_WINDOW})

but below critical system windows like the status bar or IME.

The system may change the position, size, or visibility of these windows at anytime

to reduce visual clutter to the user and also manage resources.

Requires {@link android.Manifest.permission#SYSTEM_ALERT_WINDOW} permission.

The system will adjust the importance of processes with this window type to reduce the

chance of the low-memory-killer killing them.

In multi-user systems shows only on the owning user’s screen.
/
public static final int TYPE_APPLICATION_OVERLAY = FIRST_SYSTEM_WINDOW + 38;
/*

End of types of system windows.
/
public static final int LAST_SYSTEM_WINDOW = 2999;
/*

@hide

Used internally when there is no suitable type available.
/
public static final int INVALID_WINDOW_TYPE = -1;
/*

Return true if the window type is an alert window.

@param type The window type.

@return If the window type is an alert window.

@hide
/
public static boolean isSystemAlertWindowType(int type) {
switch (type) {
case TYPE_PHONE:
case TYPE_PRIORITY_PHONE:
case TYPE_SYSTEM_ALERT:
case TYPE_SYSTEM_ERROR:
case TYPE_SYSTEM_OVERLAY:
case TYPE_APPLICATION_OVERLAY:
return true;
}
return false;
}
/* @deprecated this is ignored, this value is set automatically when needed. /
@Deprecated
public static final int MEMORY_TYPE_NORMAL = 0;
/* @deprecated this is ignored, this value is set automatically when needed. /
@Deprecated
public static final int MEMORY_TYPE_HARDWARE = 1;
/* @deprecated this is ignored, this value is set automatically when needed. /
@Deprecated
public static final int MEMORY_TYPE_GPU = 2;
/* @deprecated this is ignored, this value is set automatically when needed. /
@Deprecated
public static final int MEMORY_TYPE_PUSH_BUFFERS = 3;
/*

@deprecated this is ignored
/
@Deprecated
public int memoryType;
/* 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.

@deprecated Blurring is no longer supported. /
@Deprecated
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.

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.

@deprecated This flag has no effect.
/
@Deprecated
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 (such as 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 (such as the 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. A fullscreen window

will ignore a value of {@link #SOFT_INPUT_ADJUST_RESIZE} for the window’s

{@link #softInputMode} field; the window will stay fullscreen

and will not resize.

This flag can be controlled in your theme through the

{@link android.R.attr#windowFullscreen} attribute; this attribute

is automatically set for you in the standard fullscreen themes

such as {@link android.R.style#Theme_NoTitleBar_Fullscreen},

{@link android.R.style#Theme_Black_NoTitleBar_Fullscreen},

{@link android.R.style#Theme_Light_NoTitleBar_Fullscreen},

{@link android.R.style#Theme_Holo_NoActionBar_Fullscreen},

{@link android.R.style#Theme_Holo_Light_NoActionBar_Fullscreen},

{@link android.R.style#Theme_DeviceDefault_NoActionBar_Fullscreen}, and

{@link android.R.style#Theme_DeviceDefault_Light_NoActionBar_Fullscreen}.
/
public static final int FLAG_FULLSCREEN = 0x00000400;
/* Window flag: override {@link #FLAG_FULLSCREEN} and force the

screen decorations (such as the 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.

@deprecated This flag is no longer used. /
@Deprecated
public static final int FLAG_DITHER = 0x00001000;
/* Window flag: treat the content of the window as secure, preventing

it from appearing in screenshots or from being viewed on non-secure

displays.

See {@link android.view.Display#FLAG_SECURE} for more details about

secure surfaces and secure displays.
/
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.

@deprecated Use {@link android.R.attr#showWhenLocked} or

{@link android.app.Activity#setShowWhenLocked(boolean)} instead to prevent an

unintentional double life-cycle event.
/
@Deprecated
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.

This flag can be controlled in your theme through the

{@link android.R.attr#windowShowWallpaper} attribute; this attribute

is automatically set for you in the standard wallpaper themes

such as {@link android.R.style#Theme_Wallpaper},

{@link android.R.style#Theme_Wallpaper_NoTitleBar},

{@link android.R.style#Theme_Wallpaper_NoTitleBar_Fullscreen},

{@link android.R.style#Theme_Holo_Wallpaper},

{@link android.R.style#Theme_Holo_Wallpaper_NoTitleBar},

{@link android.R.style#Theme_DeviceDefault_Wallpaper}, and

{@link android.R.style#Theme_DeviceDefault_Wallpaper_NoTitleBar}.
/
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.

@deprecated Use {@link android.R.attr#turnScreenOn} or

{@link android.app.Activity#setTurnScreenOn(boolean)} instead to prevent an

unintentional double life-cycle event.
/
@Deprecated
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 credential) than

the user will still need to confirm it before seeing this window,

unless {@link #FLAG_SHOW_WHEN_LOCKED} has also been set.

@deprecated Use {@link #FLAG_SHOW_WHEN_LOCKED} or

{@link KeyguardManager#requestDismissKeyguard} instead.

Since keyguard was dismissed all the time as long as an

activity with this flag on its window was focused,

keyguard couldn’t guard against unintentional touches on

the screen, which isn’t desired.
/
@Deprecated
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.
/
public static final int FLAG_SPLIT_TOUCH = 0x00800000;
/*

Indicates whether this window should be hardware accelerated.

Requesting hardware acceleration does not guarantee it will happen.

This flag can be controlled programmatically only to enable

hardware acceleration. To enable hardware acceleration for a given

window programmatically, do the following:

Window w = activity.getWindow(); // in Activity’s onCreate() for instance

w.setFlags(WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED,

WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED);

It is important to remember that this flag must

be set before setting the content view of your activity or dialog.

This flag cannot be used to disable hardware acceleration after it

was enabled in your manifest using

{@link android.R.attr#hardwareAccelerated}. If you need to selectively

and programmatically disable hardware acceleration (for automated testing

for instance), make sure it is turned off in your manifest and enable it

on your activity or dialog when you need it instead, using the method

described above.

This flag is automatically set by the system if the

{@link android.R.attr#hardwareAccelerated android:hardwareAccelerated}

XML attribute is set to true on an activity or on the application.
/
public static final int FLAG_HARDWARE_ACCELERATED = 0x01000000;
/*

Window flag: allow window contents to extend in to the screen’s

overscan area, if there is one. The window should still correctly

position its contents to take the overscan area into account.

This flag can be controlled in your theme through the

{@link android.R.attr#windowOverscan} attribute; this attribute

is automatically set for you in the standard overscan themes

such as

{@link android.R.style#Theme_Holo_NoActionBar_Overscan},

{@link android.R.style#Theme_Holo_Light_NoActionBar_Overscan},

{@link android.R.style#Theme_DeviceDefault_NoActionBar_Overscan}, and

{@link android.R.style#Theme_DeviceDefault_Light_NoActionBar_Overscan}.

When this flag is enabled for a window, its normal content may be obscured

to some degree by the overscan region of the display. To ensure key parts of

that content are visible to the user, you can use

{@link View#setFitsSystemWindows(boolean) View.setFitsSystemWindows(boolean)}

to set the point in the view hierarchy where the appropriate offsets should

be applied. (This can be done either by directly calling this function, using

the {@link android.R.attr#fitsSystemWindows} attribute in your view hierarchy,

or implementing you own {@link View#fitSystemWindows(android.graphics.Rect)

View.fitSystemWindows(Rect)} method).

This mechanism for positioning content elements is identical to its equivalent

use with layout and {@link View#setSystemUiVisibility(int)

View.setSystemUiVisibility(int)}; here is an example layout that will correctly

position its UI elements with this overscan flag is set:

{@sample development/samples/ApiDemos/res/layout/overscan_activity.xml complete}
/
public static final int FLAG_LAYOUT_IN_OVERSCAN = 0x02000000;
/*

Window flag: request a translucent status bar with minimal system-provided

background protection.

This flag can be controlled in your theme through the

{@link android.R.attr#windowTranslucentStatus} attribute; this attribute

is automatically set for you in the standard translucent decor themes

such as

{@link android.R.style#Theme_Holo_NoActionBar_TranslucentDecor},

{@link android.R.style#Theme_Holo_Light_NoActionBar_TranslucentDecor},

{@link android.R.style#Theme_DeviceDefault_NoActionBar_TranslucentDecor}, and

{@link android.R.style#Theme_DeviceDefault_Light_NoActionBar_TranslucentDecor}.

When this flag is enabled for a window, it automatically sets

the system UI visibility flags {@link View#SYSTEM_UI_FLAG_LAYOUT_STABLE} and

{@link View#SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN}.
/
public static final int FLAG_TRANSLUCENT_STATUS = 0x04000000;
/*

Window flag: request a translucent navigation bar with minimal system-provided

background protection.

This flag can be controlled in your theme through the

{@link android.R.attr#windowTranslucentNavigation} attribute; this attribute

is automatically set for you in the standard translucent decor themes

such as

{@link android.R.style#Theme_Holo_NoActionBar_TranslucentDecor},

{@link android.R.style#Theme_Holo_Light_NoActionBar_TranslucentDecor},

{@link android.R.style#Theme_DeviceDefault_NoActionBar_TranslucentDecor}, and

{@link android.R.style#Theme_DeviceDefault_Light_NoActionBar_TranslucentDecor}.

When this flag is enabled for a window, it automatically sets

the system UI visibility flags {@link View#SYSTEM_UI_FLAG_LAYOUT_STABLE} and

{@link View#SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION}.
/
public static final int FLAG_TRANSLUCENT_NAVIGATION = 0x08000000;
/*

Flag for a window in local focus mode.

Window in local focus mode can control focus independent of window manager using

{@link Window#setLocalFocus(boolean, boolean)}.

Usually window in this mode will not get touch/key events from window manager, but will

get events only via local injection using {@link Window#injectInputEvent(InputEvent)}.
/
public static final int FLAG_LOCAL_FOCUS_MODE = 0x10000000;
/* Window flag: Enable touches to slide out of a window into neighboring

windows in mid-gesture instead of being captured for the duration of

the gesture.

This flag changes the behavior of touch focus for this window only.

Touches can slide out of the window but they cannot necessarily slide

back in (unless the other window with touch focus permits it).

{@hide}
/
public static final int FLAG_SLIPPERY = 0x20000000;
/*

Window flag: When requesting layout with an attached window, the attached window may

overlap with the screen decorations of the parent window such as the navigation bar. By

including this flag, the window manager will layout the attached window within the decor

frame of the parent window such that it doesn’t overlap with screen decorations.
/
public static final int FLAG_LAYOUT_ATTACHED_IN_DECOR = 0x40000000;
/*

Flag indicating that this Window is responsible for drawing the background for the

system bars. If set, the system bars are drawn with a transparent background and the

corresponding areas in this window are filled with the colors specified in

{@link Window#getStatusBarColor()} and {@link Window#getNavigationBarColor()}.
/
public static final int FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS = 0x80000000;
/*

Various behavioral options/flags. Default is none.

@see #FLAG_ALLOW_LOCK_WHILE_SCREEN_ON

@see #FLAG_DIM_BEHIND

@see #FLAG_NOT_FOCUSABLE

@see #FLAG_NOT_TOUCHABLE

@see #FLAG_NOT_TOUCH_MODAL

@see #FLAG_TOUCHABLE_WHEN_WAKING

@see #FLAG_KEEP_SCREEN_ON

@see #FLAG_LAYOUT_IN_SCREEN

@see #FLAG_LAYOUT_NO_LIMITS

@see #FLAG_FULLSCREEN

@see #FLAG_FORCE_NOT_FULLSCREEN

@see #FLAG_SECURE

@see #FLAG_SCALED

@see #FLAG_IGNORE_CHEEK_PRESSES

@see #FLAG_LAYOUT_INSET_DECOR

@see #FLAG_ALT_FOCUSABLE_IM

@see #FLAG_WATCH_OUTSIDE_TOUCH

@see #FLAG_SHOW_WHEN_LOCKED

@see #FLAG_SHOW_WALLPAPER

@see #FLAG_TURN_SCREEN_ON

@see #FLAG_DISMISS_KEYGUARD

@see #FLAG_SPLIT_TOUCH

@see #FLAG_HARDWARE_ACCELERATED

@see #FLAG_LOCAL_FOCUS_MODE

@see #FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS
/
@ViewDebug.ExportedProperty(flagMapping = {
@ViewDebug.FlagToString(mask = FLAG_ALLOW_LOCK_WHILE_SCREEN_ON, equals = FLAG_ALLOW_LOCK_WHILE_SCREEN_ON,
name = “FLAG_ALLOW_LOCK_WHILE_SCREEN_ON”),
@ViewDebug.FlagToString(mask = FLAG_DIM_BEHIND, equals = FLAG_DIM_BEHIND,
name = “FLAG_DIM_BEHIND”),
@ViewDebug.FlagToString(mask = FLAG_BLUR_BEHIND, equals = FLAG_BLUR_BEHIND,
name = “FLAG_BLUR_BEHIND”),
@ViewDebug.FlagToString(mask = FLAG_NOT_FOCUSABLE, equals = FLAG_NOT_FOCUSABLE,
name = “FLAG_NOT_FOCUSABLE”),
@ViewDebug.FlagToString(mask = FLAG_NOT_TOUCHABLE, equals = FLAG_NOT_TOUCHABLE,
name = “FLAG_NOT_TOUCHABLE”),
@ViewDebug.FlagToString(mask = FLAG_NOT_TOUCH_MODAL, equals = FLAG_NOT_TOUCH_MODAL,
name = “FLAG_NOT_TOUCH_MODAL”),
@ViewDebug.FlagToString(mask = FLAG_TOUCHABLE_WHEN_WAKING, equals = FLAG_TOUCHABLE_WHEN_WAKING,
name = “FLAG_TOUCHABLE_WHEN_WAKING”),
@ViewDebug.FlagToString(mask = FLAG_KEEP_SCREEN_ON, equals = FLAG_KEEP_SCREEN_ON,
name = “FLAG_KEEP_SCREEN_ON”),
@ViewDebug.FlagToString(mask = FLAG_LAYOUT_IN_SCREEN, equals = FLAG_LAYOUT_IN_SCREEN,
name = “FLAG_LAYOUT_IN_SCREEN”),
@ViewDebug.FlagToString(mask = FLAG_LAYOUT_NO_LIMITS, equals = FLAG_LAYOUT_NO_LIMITS,
name = “FLAG_LAYOUT_NO_LIMITS”),
@ViewDebug.FlagToString(mask = FLAG_FULLSCREEN, equals = FLAG_FULLSCREEN,
name = “FLAG_FULLSCREEN”),
@ViewDebug.FlagToString(mask = FLAG_FORCE_NOT_FULLSCREEN, equals = FLAG_FORCE_NOT_FULLSCREEN,
name = “FLAG_FORCE_NOT_FULLSCREEN”),
@ViewDebug.FlagToString(mask = FLAG_DITHER, equals = FLAG_DITHER,
name = “FLAG_DITHER”),
@ViewDebug.FlagToString(mask = FLAG_SECURE, equals = FLAG_SECURE,
name = “FLAG_SECURE”),
@ViewDebug.FlagToString(mask = FLAG_SCALED, equals = FLAG_SCALED,
name = “FLAG_SCALED”),
@ViewDebug.FlagToString(mask = FLAG_IGNORE_CHEEK_PRESSES, equals = FLAG_IGNORE_CHEEK_PRESSES,
name = “FLAG_IGNORE_CHEEK_PRESSES”),
@ViewDebug.FlagToString(mask = FLAG_LAYOUT_INSET_DECOR, equals = FLAG_LAYOUT_INSET_DECOR,
name = “FLAG_LAYOUT_INSET_DECOR”),
@ViewDebug.FlagToString(mask = FLAG_ALT_FOCUSABLE_IM, equals = FLAG_ALT_FOCUSABLE_IM,
name = “FLAG_ALT_FOCUSABLE_IM”),
@ViewDebug.FlagToString(mask = FLAG_WATCH_OUTSIDE_TOUCH, equals = FLAG_WATCH_OUTSIDE_TOUCH,
name = “FLAG_WATCH_OUTSIDE_TOUCH”),
@ViewDebug.FlagToString(mask = FLAG_SHOW_WHEN_LOCKED, equals = FLAG_SHOW_WHEN_LOCKED,
name = “FLAG_SHOW_WHEN_LOCKED”),
@ViewDebug.FlagToString(mask = FLAG_SHOW_WALLPAPER, equals = FLAG_SHOW_WALLPAPER,
name = “FLAG_SHOW_WALLPAPER”),
@ViewDebug.FlagToString(mask = FLAG_TURN_SCREEN_ON, equals = FLAG_TURN_SCREEN_ON,
name = “FLAG_TURN_SCREEN_ON”),
@ViewDebug.FlagToString(mask = FLAG_DISMISS_KEYGUARD, equals = FLAG_DISMISS_KEYGUARD,
name = “FLAG_DISMISS_KEYGUARD”),
@ViewDebug.FlagToString(mask = FLAG_SPLIT_TOUCH, equals = FLAG_SPLIT_TOUCH,
name = “FLAG_SPLIT_TOUCH”),
@ViewDebug.FlagToString(mask = FLAG_HARDWARE_ACCELERATED, equals = FLAG_HARDWARE_ACCELERATED,
name = “FLAG_HARDWARE_ACCELERATED”),
@ViewDebug.FlagToString(mask = FLAG_LOCAL_FOCUS_MODE, equals = FLAG_LOCAL_FOCUS_MODE,
name = “FLAG_LOCAL_FOCUS_MODE”),
@ViewDebug.FlagToString(mask = FLAG_TRANSLUCENT_STATUS, equals = FLAG_TRANSLUCENT_STATUS,
name = “FLAG_TRANSLUCENT_STATUS”),
@ViewDebug.FlagToString(mask = FLAG_TRANSLUCENT_NAVIGATION, equals = FLAG_TRANSLUCENT_NAVIGATION,
name = “FLAG_TRANSLUCENT_NAVIGATION”),
@ViewDebug.FlagToString(mask = FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS, equals = FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS,
name = “FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS”)
}, formatToHexString = true)
public int flags;
/*

If the window has requested hardware acceleration, but this is not

allowed in the process it is in, then still render it as if it is

hardware accelerated. This is used for the starting preview windows

in the system process, which don’t need to have the overhead of

hardware acceleration (they are just a static rendering), but should

be rendered as such to match the actual window of the app even if it

is hardware accelerated.

Even if the window isn’t hardware accelerated, still do its rendering

as if it was.

Like {@link #FLAG_HARDWARE_ACCELERATED} except for trusted system windows

that need hardware acceleration (e.g. LockScreen), where hardware acceleration

is generally disabled. This flag must be specified in addition to

{@link #FLAG_HARDWARE_ACCELERATED} to enable hardware acceleration for system

windows.

@hide
/
public static final int PRIVATE_FLAG_FAKE_HARDWARE_ACCELERATED = 0x00000001;
/*

In the system process, we globally do not use hardware acceleration

because there are many threads doing UI there and they conflict.

If certain parts of the UI that really do want to use hardware

acceleration, this flag can be set to force it. This is basically

for the lock screen. Anyone else using it, you are probably wrong.

@hide
/
public static final int PRIVATE_FLAG_FORCE_HARDWARE_ACCELERATED = 0x00000002;
/*

By default, wallpapers are sent new offsets when the wallpaper is scrolled. Wallpapers

may elect to skip these notifications if they are not doing anything productive with

them (they do not affect the wallpaper scrolling operation) by calling

{@link

android.service.wallpaper.WallpaperService.Engine#setOffsetNotificationsEnabled(boolean)}.

@hide
/
public static final int PRIVATE_FLAG_WANTS_OFFSET_NOTIFICATIONS = 0x00000004;
/* In a multiuser system if this flag is set and the owner is a system process then this

window will appear on all user screens. This overrides the default behavior of window

types that normally only appear on the owning user’s screen. Refer to each window type

to determine its default behavior.

{@hide} /
public static final int PRIVATE_FLAG_SHOW_FOR_ALL_USERS = 0x00000010;
/*

Never animate position changes of the window.

{@hide}
/
@TestApi
public static final int PRIVATE_FLAG_NO_MOVE_ANIMATION = 0x00000040;
/* 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 PRIVATE_FLAG_COMPATIBLE_WINDOW = 0x00000080;
/* 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 PRIVATE_FLAG_SYSTEM_ERROR = 0x00000100;
/* Window flag: maintain the previous translucent decor state when this window

becomes top-most.

{@hide} /
public static final int PRIVATE_FLAG_INHERIT_TRANSLUCENT_DECOR = 0x00000200;
/*

Flag whether the current window is a keyguard window, meaning that it will hide all other

windows behind it except for windows with flag {@link #FLAG_SHOW_WHEN_LOCKED} set.

Further, this can only be set by {@link LayoutParams#TYPE_STATUS_BAR}.

{@hide}
/
public static final int PRIVATE_FLAG_KEYGUARD = 0x00000400;
/*

Flag that prevents the wallpaper behind the current window from receiving touch events.

{@hide}
/
public static final int PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS = 0x00000800;
/*

Flag to force the status bar window to be visible all the time. If the bar is hidden when

this flag is set it will be shown again and the bar will have a transparent background.

This can only be set by {@link LayoutParams#TYPE_STATUS_BAR}.

{@hide}
/
public static final int PRIVATE_FLAG_FORCE_STATUS_BAR_VISIBLE_TRANSPARENT = 0x00001000;
/*

Flag indicating that the x, y, width, and height members should be

ignored (and thus their previous value preserved). For example

because they are being managed externally through repositionChild.

{@hide}
/
public static final int PRIVATE_FLAG_PRESERVE_GEOMETRY = 0x00002000;
/*

Flag that will make window ignore app visibility and instead depend purely on the decor

view visibility for determining window visibility. This is used by recents to keep

drawing after it launches an app.

@hide
/
public static final int PRIVATE_FLAG_FORCE_DECOR_VIEW_VISIBILITY = 0x00004000;
/*

Flag to indicate that this window is not expected to be replaced across

configuration change triggered activity relaunches. In general the WindowManager

expects Windows to be replaced after relaunch, and thus it will preserve their surfaces

until the replacement is ready to show in order to prevent visual glitch. However

some windows, such as PopupWindows expect to be cleared across configuration change,

and thus should hint to the WindowManager that it should not wait for a replacement.

@hide
/
public static final int PRIVATE_FLAG_WILL_NOT_REPLACE_ON_RELAUNCH = 0x00008000;
/*

Flag to indicate that this child window should always be laid-out in the parent

frame regardless of the current windowing mode configuration.

@hide
/
public static final int PRIVATE_FLAG_LAYOUT_CHILD_WINDOW_IN_PARENT_FRAME = 0x00010000;
/*

Flag to indicate that this window is always drawing the status bar background, no matter

what the other flags are.

@hide
/
public static final int PRIVATE_FLAG_FORCE_DRAW_STATUS_BAR_BACKGROUND = 0x00020000;
/*

Flag to indicate that this window needs Sustained Performance Mode if

the device supports it.

@hide
/
public static final int PRIVATE_FLAG_SUSTAINED_PERFORMANCE_MODE = 0x00040000;
/*

Flag to indicate that any window added by an application process that is of type

{@link #TYPE_TOAST} or that requires

{@link android.app.AppOpsManager#OP_SYSTEM_ALERT_WINDOW} permission should be hidden when

this window is visible.

@hide
/
@RequiresPermission(android.Manifest.permission.HIDE_NON_SYSTEM_OVERLAY_WINDOWS)
public static final int PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS = 0x00080000;
/*

Indicates that this window is the rounded corners overlay present on some

devices this means that it will be excluded from: screenshots,

screen magnification, and mirroring.

@hide
/
public static final int PRIVATE_FLAG_IS_ROUNDED_CORNERS_OVERLAY = 0x00100000;
/*

If this flag is set on the window, window manager will acquire a sleep token that puts

all activities to sleep as long as this window is visible. When this flag is set, the

window needs to occlude all activity windows.

@hide
/
@RequiresPermission(permission.DEVICE_POWER)
public static final int PRIVATE_FLAG_ACQUIRES_SLEEP_TOKEN = 0x00200000;
/*

Control flags that are private to the platform.

@hide
/
@TestApi
public int privateFlags;
/*

Value for {@link #needsMenuKey} for a window that has not explicitly specified if it

needs {@link #NEEDS_MENU_SET_TRUE} or doesn’t need {@link #NEEDS_MENU_SET_FALSE} a menu

key. For this case, we should look at windows behind it to determine the appropriate

value.

@hide
/
public static final int NEEDS_MENU_UNSET = 0;
/*

Value for {@link #needsMenuKey} for a window that has explicitly specified it needs a

menu key.

@hide
/
public static final int NEEDS_MENU_SET_TRUE = 1;
/*

Value for {@link #needsMenuKey} for a window that has explicitly specified it doesn’t

needs a menu key.

@hide
/
public static final int NEEDS_MENU_SET_FALSE = 2;
/*

State variable for a window belonging to an activity that responds to

{@link KeyEvent#KEYCODE_MENU} and therefore needs a Menu key. For devices where Menu is a

physical button this variable is ignored, but on devices where the Menu key is drawn in

software it may be hidden unless this variable is set to {@link #NEEDS_MENU_SET_TRUE}.

(Note that Action Bars, when available, are the preferred way to offer additional

functions otherwise accessed via an options menu.)

{@hide}
/
public int needsMenuKey = NEEDS_MENU_UNSET;
/*

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 not 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. If the window’s

layout parameter flags include {@link #FLAG_FULLSCREEN}, this

value for {@link #softInputMode} will be ignored; the window will

not resize, but will stay fullscreen.
/
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 not 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;
/* Adjustment option for {@link #softInputMode}: set to have a window

not adjust for a shown input method. The window will not be resized,

and it will not be panned to make its focus visible.
/
public static final int SOFT_INPUT_ADJUST_NOTHING = 0x30;
/*

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;
/*

An internal annotation for flags that can be specified to {@link #softInputMode}.

@hide
/
@Retention(RetentionPolicy.SOURCE)
@IntDef(flag = true, value = {
SOFT_INPUT_STATE_UNSPECIFIED,
SOFT_INPUT_STATE_UNCHANGED,
SOFT_INPUT_STATE_HIDDEN,
SOFT_INPUT_STATE_ALWAYS_HIDDEN,
SOFT_INPUT_STATE_VISIBLE,
SOFT_INPUT_STATE_ALWAYS_VISIBLE,
SOFT_INPUT_ADJUST_UNSPECIFIED,
SOFT_INPUT_ADJUST_RESIZE,
SOFT_INPUT_ADJUST_PAN,
SOFT_INPUT_ADJUST_NOTHING,
SOFT_INPUT_IS_FORWARD_NAVIGATION,
})
public @interface SoftInputModeFlags {}
/*

Desired operating mode for any soft input area. May be any combination

of:

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_HIDDEN},

{@link #SOFT_INPUT_STATE_VISIBLE}, or {@link #SOFT_INPUT_STATE_ALWAYS_VISIBLE}.

One of the adjustment options

{@link #SOFT_INPUT_ADJUST_UNSPECIFIED}, {@link #SOFT_INPUT_ADJUST_RESIZE},

{@link #SOFT_INPUT_ADJUST_PAN}, or {@link #SOFT_INPUT_ADJUST_NOTHING}.

This flag can be controlled in your theme through the

{@link android.R.attr#windowSoftInputMode} attribute.
/
@SoftInputModeFlags
public int softInputMode;
/*

Placement of window within the screen as per {@link Gravity}. Both

{@link Gravity#apply(int, int, int, android.graphics.Rect, int, int,

android.graphics.Rect) Gravity.apply} and

{@link Gravity#applyDisplay(int, android.graphics.Rect, android.graphics.Rect)

Gravity.applyDisplay} are used during window layout, with this value

given as the desired gravity. For example you can specify

{@link Gravity#DISPLAY_CLIP_HORIZONTAL Gravity.DISPLAY_CLIP_HORIZONTAL} and

{@link Gravity#DISPLAY_CLIP_VERTICAL Gravity.DISPLAY_CLIP_VERTICAL} here

to control the behavior of

{@link Gravity#applyDisplay(int, android.graphics.Rect, android.graphics.Rect)

Gravity.applyDisplay}.

@see Gravity
/
public int gravity;
/*

The horizontal margin, as a percentage of the container’s width,

between the container and the widget. See

{@link Gravity#apply(int, int, int, android.graphics.Rect, int, int,

android.graphics.Rect) Gravity.apply} for how this is used. This

field is added with {@link #x} to supply the xAdj parameter.
/
public float horizontalMargin;
/*

The vertical margin, as a percentage of the container’s height,

between the container and the widget. See

{@link Gravity#apply(int, int, int, android.graphics.Rect, int, int,

android.graphics.Rect) Gravity.apply} for how this is used. This

field is added with {@link #y} to supply the yAdj parameter.
/
public float verticalMargin;
/*

Positive insets between the drawing surface and window content.

@hide
/
public final Rect surfaceInsets = new Rect();
/*

Whether the surface insets have been manually set. When set to

{@code false}, the view root will automatically determine the

appropriate surface insets.

@see #surfaceInsets

@hide
/
public boolean hasManualSurfaceInsets;
/*

Whether the previous surface insets should be used vs. what is currently set. When set

to {@code true}, the view root will ignore surfaces insets in this object and use what

it currently has.

@see #surfaceInsets

@hide
/
public boolean preservePreviousSurfaceInsets = true;
/*

The desired bitmap format. May be one of the constants in

{@link android.graphics.PixelFormat}. The choice of format

might be overridden by {@link #setColorMode(int)}. 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;
/*

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;
/*

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;
/*

Unspecified value for {@link #rotationAnimation} indicating

a lack of preference.

@hide
/
public static final int ROTATION_ANIMATION_UNSPECIFIED = -1;
/*

Value for {@link #rotationAnimation} which specifies that this

window will visually rotate in or out following a rotation.
/
public static final int ROTATION_ANIMATION_ROTATE = 0;
/*

Value for {@link #rotationAnimation} which specifies that this

window will fade in or out following a rotation.
/
public static final int ROTATION_ANIMATION_CROSSFADE = 1;
/*

Value for {@link #rotationAnimation} which specifies that this window

will immediately disappear or appear following a rotation.
/
public static final int ROTATION_ANIMATION_JUMPCUT = 2;
/*

Value for {@link #rotationAnimation} to specify seamless rotation mode.

This works like JUMPCUT but will fall back to CROSSFADE if rotation

can’t be applied without pausing the screen. For example, this is ideal

for Camera apps which don’t want the viewfinder contents to ever rotate

or fade (and rather to be seamless) but also don’t want ROTATION_ANIMATION_JUMPCUT

during app transition scenarios where seamless rotation can’t be applied.
/
public static final int ROTATION_ANIMATION_SEAMLESS = 3;
/*

Define the exit and entry animations used on this window when the device is rotated.

This only has an affect if the incoming and outgoing topmost

opaque windows have the #FLAG_FULLSCREEN bit set and are not covered

by other windows. All other situations default to the

{@link #ROTATION_ANIMATION_ROTATE} behavior.

@see #ROTATION_ANIMATION_ROTATE

@see #ROTATION_ANIMATION_CROSSFADE

@see #ROTATION_ANIMATION_JUMPCUT
/
public int rotationAnimation = ROTATION_ANIMATION_ROTATE;
/*

Identifier for this window. This will usually be filled in for

you.
/
public IBinder token = null;
/*

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;
/*

The preferred refresh rate for the window.

This must be one of the supported refresh rates obtained for the display(s) the window

is on. The selected refresh rate will be applied to the display’s default mode.

This value is ignored if {@link #preferredDisplayModeId} is set.

@see Display#getSupportedRefreshRates()

@deprecated use {@link #preferredDisplayModeId} instead
/
@Deprecated
public float preferredRefreshRate;
/*

Id of the preferred display mode for the window.

This must be one of the supported modes obtained for the display(s) the window is on.

A value of {@code 0} means no preference.

@see Display#getSupportedModes()

@see Display.Mode#getModeId()
/
public int preferredDisplayModeId;
/*

Control the visibility of the status bar.

@see View#STATUS_BAR_VISIBLE

@see View#STATUS_BAR_HIDDEN
/
public int systemUiVisibility;
/*

@hide

The ui visibility as requested by the views in this hierarchy.

the combined value should be systemUiVisibility | subtreeSystemUiVisibility.
/
public int subtreeSystemUiVisibility;
/*

Get callbacks about the system ui visibility changing.

TODO: Maybe there should be a bitfield of optional callbacks that we need.

@hide
/
public boolean hasSystemUiListeners;
/*

When this window has focus, disable touch pad pointer gesture processing.

The window will receive raw position updates from the touch pad instead

of pointer movements and synthetic touch events.

@hide
/
public static final int INPUT_FEATURE_DISABLE_POINTER_GESTURES = 0x00000001;
/*

Does not construct an input channel for this window. The channel will therefore

be incapable of receiving input.

@hide
/
public static final int INPUT_FEATURE_NO_INPUT_CHANNEL = 0x00000002;
/*

When this window has focus, does not call user activity for all input events so

the application will have to do it itself. Should only be used by

the keyguard and phone app.

Should only be used by the keyguard and phone app.

@hide
/
public static final int INPUT_FEATURE_DISABLE_USER_ACTIVITY = 0x00000004;
/*

Control special features of the input subsystem.

@see #INPUT_FEATURE_DISABLE_POINTER_GESTURES

@see #INPUT_FEATURE_NO_INPUT_CHANNEL

@see #INPUT_FEATURE_DISABLE_USER_ACTIVITY

@hide
/
public int inputFeatures;
/*

Sets the number of milliseconds before the user activity timeout occurs

when this window has focus. A value of -1 uses the standard timeout.

A value of 0 uses the minimum support display timeout.

This property can only be used to reduce the user specified display timeout;

it can never make the timeout longer than it normally would be.

Should only be used by the keyguard and phone app.

@hide
/
public long userActivityTimeout = -1;
/*

For windows with an anchor (e.g. PopupWindow), keeps track of the View that anchors the

window.

@hide
/
public int accessibilityIdOfAnchor = -1;
/*

The window title isn’t kept in sync with what is displayed in the title bar, so we

separately track the currently shown title to provide to accessibility.

@hide
/
@TestApi
public CharSequence accessibilityTitle;
/*

Sets a timeout in milliseconds before which the window will be hidden

by the window manager. Useful for transient notifications like toasts

so we don’t have to rely on client cooperation to ensure the window

is hidden. Must be specified at window creation time. Note that apps

are not prepared to handle their windows being removed without their

explicit request and may try to interact with the removed window

resulting in undefined behavior and crashes. Therefore, we do hide

such windows to prevent them from overlaying other apps.

@hide
/
public long hideTimeoutMilliseconds = -1;
/*

The color mode requested by this window. The target display may

not be able to honor the request. When the color mode is not set

to {@link ActivityInfo#COLOR_MODE_DEFAULT}, it might override the

pixel format specified in {@link #format}.

@hide
/
@ActivityInfo.ColorMode
private int mColorMode = ActivityInfo.COLOR_MODE_DEFAULT;
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 = TextUtils.stringOrSpannedString(title);
}
public final CharSequence getTitle() {
return mTitle != null ? mTitle : “”;
}
/*

Sets the surface insets based on the elevation (visual z position) of the input view.

@hide
/
public final void setSurfaceInsets(View view, boolean manual, boolean preservePrevious) {
final int surfaceInset = (int) Math.ceil(view.getZ() * 2);
// Partial workaround for b/28318973. Every inset change causes a freeform window
// to jump a little for a few frames. If we never allow surface insets to decrease,
// they will stabilize quickly (often from the very beginning, as most windows start
// as focused).
// TODO(b/22668382) to fix this properly.
if (surfaceInset == 0) {
// OK to have 0 (this is the case for non-freeform windows).
surfaceInsets.set(0, 0, 0, 0);
} else {
surfaceInsets.set(
Math.max(surfaceInset, surfaceInsets.left),
Math.max(surfaceInset, surfaceInsets.top),
Math.max(surfaceInset, surfaceInsets.right),
Math.max(surfaceInset, surfaceInsets.bottom));
}
hasManualSurfaceInsets = manual;
preservePreviousSurfaceInsets = preservePrevious;
}
/*

Set the color mode of the window. Setting the color mode might

override the window’s pixel {@link WindowManager.LayoutParams#format format}.

The color mode must be one of {@link ActivityInfo#COLOR_MODE_DEFAULT},

{@link ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT} or

{@link ActivityInfo#COLOR_MODE_HDR}.

@see #getColorMode()
/
public void setColorMode(@ActivityInfo.ColorMode int colorMode) {
mColorMode = colorMode;
}
/*

Returns the color mode of the window, one of {@link ActivityInfo#COLOR_MODE_DEFAULT},

{@link ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT} or {@link ActivityInfo#COLOR_MODE_HDR}.

@see #setColorMode(int)
/
@ActivityInfo.ColorMode
public int getColorMode() {
return mColorMode;
}
/* @hide /
@SystemApi
public final void setUserActivityTimeout(long timeout) {
userActivityTimeout = timeout;
}
/* @hide */
@SystemApi
public final long getUserActivityTimeout() {
return userActivityTimeout;
}
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel out, int parcelableFlags) {
out.writeInt(width);
out.writeInt(height);
out.writeInt(x);
out.writeInt(y);
out.writeInt(type);
out.writeInt(flags);
out.writeInt(privateFlags);
out.writeInt(softInputMode);
out.writeInt(gravity);
out.writeFloat(horizontalMargin);
out.writeFloat(verticalMargin);
out.writeInt(format);
out.writeInt(windowAnimations);
out.writeFloat(alpha);
out.writeFloat(dimAmount);
out.writeFloat(screenBrightness);
out.writeFloat(buttonBrightness);
out.writeInt(rotationAnimation);
out.writeStrongBinder(token);
out.writeString(packageName);
TextUtils.writeToParcel(mTitle, out, parcelableFlags);
out.writeInt(screenOrientation);
out.writeFloat(preferredRefreshRate);
out.writeInt(preferredDisplayModeId);
out.writeInt(systemUiVisibility);
out.writeInt(subtreeSystemUiVisibility);
out.writeInt(hasSystemUiListeners ? 1 : 0);
out.writeInt(inputFeatures);
out.writeLong(userActivityTimeout);
out.writeInt(surfaceInsets.left);
out.writeInt(surfaceInsets.top);
out.writeInt(surfaceInsets.right);
out.writeInt(surfaceInsets.bottom);
out.writeInt(hasManualSurfaceInsets ? 1 : 0);
out.writeInt(preservePreviousSurfaceInsets ? 1 : 0);
out.writeInt(needsMenuKey);
out.writeInt(accessibilityIdOfAnchor);
TextUtils.writeToParcel(accessibilityTitle, out, parcelableFlags);
out.writeInt(mColorMode);
out.writeLong(hideTimeoutMilliseconds);
}
public static final Parcelable.Creator CREATOR
= new Parcelable.Creator() {
public LayoutParams createFromParcel(Parcel in) {
return new LayoutParams(in);
}
public LayoutParams[] newArray(int size) {
return new LayoutParams[size];
}
};

public LayoutParams(Parcel in) {
width = in.readInt();
height = in.readInt();
x = in.readInt();
y = in.readInt();
type = in.readInt();
flags = in.readInt();
privateFlags = in.readInt();
softInputMode = in.readInt();
gravity = in.readInt();
horizontalMargin = in.readFloat();
verticalMargin = in.readFloat();
format = in.readInt();
windowAnimations = in.readInt();
alpha = in.readFloat();
dimAmount = in.readFloat();
screenBrightness = in.readFloat();
buttonBrightness = in.readFloat();
rotationAnimation = in.readInt();
token = in.readStrongBinder();
packageName = in.readString();
mTitle = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
screenOrientation = in.readInt();
preferredRefreshRate = in.readFloat();
preferredDisplayModeId = in.readInt();
systemUiVisibility = in.readInt();
subtreeSystemUiVisibility = in.readInt();
hasSystemUiListeners = in.readInt() != 0;
inputFeatures = in.readInt();
userActivityTimeout = in.readLong();
surfaceInsets.left = in.readInt();
surfaceInsets.top = in.readInt();
surfaceInsets.right = in.readInt();
surfaceInsets.bottom = in.readInt();
hasManualSurfaceInsets = in.readInt() != 0;
preservePreviousSurfaceInsets = in.readInt() != 0;
needsMenuKey = in.readInt();
accessibilityIdOfAnchor = in.readInt();
accessibilityTitle = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
mColorMode = in.readInt();
hideTimeoutMilliseconds = in.readLong();
}
@SuppressWarnings({“PointlessBitwiseExpression”})
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;
public static final int ROTATION_ANIMATION_CHANGED = 1<<12;
/** {@hide} /
public static final int BUTTON_BRIGHTNESS_CHANGED = 1<<13;
/* {@hide} /
public static final int SYSTEM_UI_VISIBILITY_CHANGED = 1<<14;
/* {@hide} /
public static final int SYSTEM_UI_LISTENER_CHANGED = 1<<15;
/* {@hide} /
public static final int INPUT_FEATURES_CHANGED = 1<<16;
/* {@hide} /
public static final int PRIVATE_FLAGS_CHANGED = 1<<17;
/* {@hide} /
public static final int USER_ACTIVITY_TIMEOUT_CHANGED = 1<<18;
/* {@hide} /
public static final int TRANSLUCENT_FLAGS_CHANGED = 1<<19;
/* {@hide} /
public static final int SURFACE_INSETS_CHANGED = 1<<20;
/* {@hide} /
public static final int PREFERRED_REFRESH_RATE_CHANGED = 1 << 21;
/* {@hide} /
public static final int NEEDS_MENU_KEY_CHANGED = 1 << 22;
/* {@hide} /
public static final int PREFERRED_DISPLAY_MODE_ID = 1 << 23;
/* {@hide} /
public static final int ACCESSIBILITY_ANCHOR_CHANGED = 1 << 24;
/* {@hide} /
@TestApi
public static final int ACCESSIBILITY_TITLE_CHANGED = 1 << 25;
/* {@hide} /
public static final int COLOR_MODE_CHANGED = 1 << 26;
/* {@hide} /
public static final int EVERYTHING_CHANGED = 0xffffffff;
// 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 (flags != o.flags) {
final int diff = flags ^ o.flags;
if ((diff & (FLAG_TRANSLUCENT_STATUS | FLAG_TRANSLUCENT_NAVIGATION)) != 0) {
changes |= TRANSLUCENT_FLAGS_CHANGED;
}
flags = o.flags;
changes |= FLAGS_CHANGED;
}
if (privateFlags != o.privateFlags) {
privateFlags = o.privateFlags;
changes |= PRIVATE_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 (format != o.format) {
format = o.format;
changes |= FORMAT_CHANGED;
}
if (windowAnimations != o.windowAnimations) {
windowAnimations = o.windowAnimations;
changes |= ANIMATION_CHANGED;
}
if (token == null) {
// NOTE: token only copied if the recipient doesn’t
// already have one.
token = o.token;
}
if (packageName == null) {
// NOTE: packageName only copied if the recipient doesn’t
// already have one.
packageName = o.packageName;
}
if (!Objects.equals(mTitle, o.mTitle) && o.mTitle != null) {
// NOTE: mTitle only copied if the originator set one.
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 (rotationAnimation != o.rotationAnimation) {
rotationAnimation = o.rotationAnimation;
changes |= ROTATION_ANIMATION_CHANGED;
}
if (screenOrientation != o.screenOrientation) {
screenOrientation = o.screenOrientation;
changes |= SCREEN_ORIENTATION_CHANGED;
}
if (preferredRefreshRate != o.preferredRefreshRate) {
preferredRefreshRate = o.preferredRefreshRate;
changes |= PREFERRED_REFRESH_RATE_CHANGED;
}
if (preferredDisplayModeId != o.preferredDisplayModeId) {
preferredDisplayModeId = o.preferredDisplayModeId;
changes |= PREFERRED_DISPLAY_MODE_ID;
}
if (systemUiVisibility != o.systemUiVisibility
|| subtreeSystemUiVisibility != o.subtreeSystemUiVisibility) {
systemUiVisibility = o.systemUiVisibility;
subtreeSystemUiVisibility = o.subtreeSystemUiVisibility;
changes |= SYSTEM_UI_VISIBILITY_CHANGED;
}
if (hasSystemUiListeners != o.hasSystemUiListeners) {
hasSystemUiListeners = o.hasSystemUiListeners;
changes |= SYSTEM_UI_LISTENER_CHANGED;
}
if (inputFeatures != o.inputFeatures) {
inputFeatures = o.inputFeatures;
changes |= INPUT_FEATURES_CHANGED;
}
if (userActivityTimeout != o.userActivityTimeout) {
userActivityTimeout = o.userActivityTimeout;
changes |= USER_ACTIVITY_TIMEOUT_CHANGED;
}
if (!surfaceInsets.equals(o.surfaceInsets)) {
surfaceInsets.set(o.surfaceInsets);
changes |= SURFACE_INSETS_CHANGED;
}
if (hasManualSurfaceInsets != o.hasManualSurfaceInsets) {
hasManualSurfaceInsets = o.hasManualSurfaceInsets;
changes |= SURFACE_INSETS_CHANGED;
}
if (preservePreviousSurfaceInsets != o.preservePreviousSurfaceInsets) {
preservePreviousSurfaceInsets = o.preservePreviousSurfaceInsets;
changes |= SURFACE_INSETS_CHANGED;
}
if (needsMenuKey != o.needsMenuKey) {
needsMenuKey = o.needsMenuKey;
changes |= NEEDS_MENU_KEY_CHANGED;
}
if (accessibilityIdOfAnchor != o.accessibilityIdOfAnchor) {
accessibilityIdOfAnchor = o.accessibilityIdOfAnchor;
changes |= ACCESSIBILITY_ANCHOR_CHANGED;
}
if (!Objects.equals(accessibilityTitle, o.accessibilityTitle)
&& o.accessibilityTitle != null) {
// NOTE: accessibilityTitle only copied if the originator set one.
accessibilityTitle = o.accessibilityTitle;
changes |= ACCESSIBILITY_TITLE_CHANGED;
}
if (mColorMode != o.mColorMode) {
mColorMode = o.mColorMode;
changes |= COLOR_MODE_CHANGED;
}
// This can’t change, it’s only set at window creation time.
hideTimeoutMilliseconds = o.hideTimeoutMilliseconds;
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”, “WindowManager.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” : String.valueOf(width))));
sb.append(‘x’);
sb.append((height == MATCH_PARENT ? “fill” : (height == WRAP_CONTENT
? “wrap” : String.valueOf(height))));
sb.append(")");
if (horizontalMargin != 0) {
sb.append(" hm=");
sb.append(horizontalMargin);
}
if (verticalMargin != 0) {
sb.append(" vm=");
sb.append(verticalMargin);
}
if (gravity != 0) {
sb.append(" gr=#");
sb.append(Integer.toHexString(gravity));
}
if (softInputMode != 0) {
sb.append(" sim=#");
sb.append(Integer.toHexString(softInputMode));
}
sb.append(" ty=");
sb.append(type);
sb.append(" fl=#");
sb.append(Integer.toHexString(flags));
if (privateFlags != 0) {
if ((privateFlags & PRIVATE_FLAG_COMPATIBLE_WINDOW) != 0) {
sb.append(" compatible=true");
}
sb.append(" pfl=0x").append(Integer.toHexString(privateFlags));
}
if (format != PixelFormat.OPAQUE) {
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 (alpha != 1.0f) {
sb.append(" alpha=");
sb.append(alpha);
}
if (screenBrightness != BRIGHTNESS_OVERRIDE_NONE) {
sb.append(" sbrt=");
sb.append(screenBrightness);
}
if (buttonBrightness != BRIGHTNESS_OVERRIDE_NONE) {
sb.append(" bbrt=");
sb.append(buttonBrightness);
}
if (rotationAnimation != ROTATION_ANIMATION_ROTATE) {
sb.append(" rotAnim=");
sb.append(rotationAnimation);
}
if (preferredRefreshRate != 0) {
sb.append(" preferredRefreshRate=");
sb.append(preferredRefreshRate);
}
if (preferredDisplayModeId != 0) {
sb.append(" preferredDisplayMode=");
sb.append(preferredDisplayModeId);
}
if (systemUiVisibility != 0) {
sb.append(" sysui=0x");
sb.append(Integer.toHexString(systemUiVisibility));
}
if (subtreeSystemUiVisibility != 0) {
sb.append(" vsysui=0x");
sb.append(Integer.toHexString(subtreeSystemUiVisibility));
}
if (hasSystemUiListeners) {
sb.append(" sysuil=");
sb.append(hasSystemUiListeners);
}
if (inputFeatures != 0) {
sb.append(" if=0x").append(Integer.toHexString(inputFeatures));
}
if (userActivityTimeout >= 0) {
sb.append(" userActivityTimeout=").append(userActivityTimeout);
}
if (surfaceInsets.left != 0 || surfaceInsets.top != 0 || surfaceInsets.right != 0 ||
surfaceInsets.bottom != 0 || hasManualSurfaceInsets
|| !preservePreviousSurfaceInsets) {
sb.append(" surfaceInsets=").append(surfaceInsets);
if (hasManualSurfaceInsets) {
sb.append(" (manual)");
}
if (!preservePreviousSurfaceInsets) {
sb.append(" (!preservePreviousSurfaceInsets)");
}
}
if (needsMenuKey != NEEDS_MENU_UNSET) {
sb.append(" needsMenuKey=");
sb.append(needsMenuKey);
}
sb.append(" colorMode=").append(mColorMode);
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 = null;
  /* @hide /
  @Override
  protected void encodeProperties(@NonNull ViewHierarchyEncoder encoder) {
  super.encodeProperties(encoder);
  encoder.addProperty(“x”, x);
  encoder.addProperty(“y”, y);
  encoder.addProperty(“horizontalWeight”, horizontalWeight);
  encoder.addProperty(“verticalWeight”, verticalWeight);
  encoder.addProperty(“type”, type);
  encoder.addProperty(“flags”, flags);
  }
  /*
• @hide
• @return True if the layout parameters will cause the window to cover the full screen;
• false otherwise.
  */
  public boolean isFullscreen() {
  return x == 0 && y == 0
  && width == WindowManager.LayoutParams.MATCH_PARENT
  && height == WindowManager.LayoutParams.MATCH_PARENT;
  }
  }
  }