Android activity change size

Tek Eye

For efficient bitmap handling or dynamic View creation in an app, the area that a screen item or layout is using needs to be known. If no fixed sizes are allocated at design time the size of a View may not be known until an app is executed. This is because of the wide range of display sizes that Android supports. Just look on GSMArena to see the huge range of Android devices produced over the years, and to see the wide variation in screen sizes and pixel densities. The example code in this article shows how to read the screen size and the size of Views as the app runs.

(Note: All Android screen items are derived from Views. A screen component, e.g. a TextView , is derived from the View class. Such screen components are also known as widgets. Layouts are ViewGroups and are also derived from Views.)

Determining the Size of an Android View or Screen at Run Time

To run the example code in this article first create a new Android project. Those new to Android programming can read the article Your First Android Hello World Java Program to see how. For this article the app is called View Size.

Use a simple layout for activity_main.xml (the layout file may have another name). Add a TextView with id labXY and set the Text attribute to X,Y. Next to it add another TextView called textXY with Text set to ? (actually \? to make it valid in the XML). Here is the layout used for this example:

Add this code to the bottom of the onCreate method in MainActivity.java (or whatever the class was called). Add the required an imports for TextView and DisplayMetrics when prompted with the Alt-Enter:

This is the code running on an Android Virtual Device (AVD) with a 320×480 screen:

Finding the Size of an Android View in Code

Drop an ImageView onto the layout, here using the ic_launcher.png icon file, or other images can be used. The size of a View can be retrieved using the getWidth and getHeight methods. Change the code in the onCreate to set the TextView to the ImageView’s width and height (an import for View is required, again usually prompted for and added with Alt-Enter):

Mmmmm! The code is showing 0,0 for the ImageView size, even though we can see that it is not 0,0:

This is because in onCreate the screen has not yet been laid out so the size of the ImageView has not been determined hence the getWidth() and getHeight() methods are returning zero. In fact they will likely return zero in onStart() and onResume(). What is needed is to override onWindowFocusChanged() to get the ImageView sizes:

Finding the Size of an Android Layout in Code

The same code can be used to get the size of the View (the layout, i.e. ViewGroup) in which the screen components sit. Notice that in the screen XML the RelativeLayout was given an id (@+id/screen), which means the base View’s width and height can be grabbed (change R.id.imageView to R.id.screen in the code):

Notice that the layout height is less than the screen height because of the notification bar.

Finding the Size of an Android View During Screen Construction

To get the the size of a View as soon as it is known (rather than waiting for the onWindowFocusChanged event) attach a listener to its ViewTreeObserver . Do this by writing a class that implements ViewTreeObserver.OnGlobalLayoutListener in the Activity’s class. This new class will have an onGlobalLayout method that gets the View dimensions that can then be stored for later use (here they are displayed as before). Here is the example source code for the entire MainActivity.java file to show this way of getting the ImageView’s width and height:

Download some example code in view-size.zip from this article, ready for importing into Android Studio. See the instructions in the zip file, alternatively the code can also be accessed via the Android Example Projects page.

See Also

• Using Immersive Full-Screen Mode on Android Developers
• See the Android Example Projects page for lots of Android sample projects with source code.
• For a full list of all the articles in Tek Eye see the full site alphabetical Index.

Archived Comments

Kestrel on December 15, 2014 at 4:20 am said: Hey fantastic article, can you also talk about the fitSystemWindows and how things are affected when its set or not set by default. Thanks in advance.

Author: Daniel S. Fowler Published: 2013-06-19 Updated: 2017-12-17

Do you have a question or comment about this article?

(Alternatively, use the email address at the bottom of the web page.)

↓markdown↓ CMS is fast and simple. Build websites quickly and publish easily. For beginner to expert.

Free Android Projects and Samples:

Источник

Анимируем изменения размеров компонента в Android

Привет, %username%! Сегодня я хотел бы поделиться с тобой способом без лишних усилий реализовать анимированное изменение размеров компонента в приложении для Android.

Я много читал про анимацию, а вот использовать в своих интерфейсах до сих пор не довелось. Хотелось опробовать наконец всякие Layout Transitions, Animators, Layout Animations и написать по этому поводу статейку, чтобы и самому лучше запомнить, и другим разжевать. Закончилось, однако, всё гораздо прозаичней — кастомным ViewGroup и ObjectAnimator’ом.

Итак, мне захотелось сделать разворачивающийся при получении фокуса EditText, как в Chrome для Android, вот такой:

Быстро прошерстив StackOverflow для определения примерного направления движения нашёл 2 варианта реализации:

1. Использовать ScaleAnimation.
2. Так или иначе пошагово менять размер EditText’а и запрашивать requestLayout() на каждом шаге.

Первый вариант я сразу отмёл, как минимум, потому что буквы тоже растянутся. Второй вариант звучит куда логичней, за исключением того, что каждый шаг будет полностью отрабатывать цикл onMeasure/onLayout/onDraw для всей ViewGroup, хотя необходимо изменить отображение только EditText’а. К тому-же я подозревал, что такая анимация вовсе не будет смотреться плавной.

Берём за основу второй способ и начинаем думать как уйти от вызова requestLayout() на каждом шаге. Но начнём, как положено, с малого.

Пишем ViewGroup

Начнём с того, что создадим кастомный ViewGroup для размещения наших компонентов:

Разметка содержит 3 элемента:

1. Кнопка «Добавить таб», имеет фиксированный размер, находится слева.
2. Кнопка «Выбрать таб», имеет фиксированный размер, находится справа.
3. Поле для ввода URL (UrlBar, наследник от EditText’а), заполняет собой оставшееся свободное пространство.

Методы onMeasure и onLayout не представляют из себя ничего сложного — сначала меряем/располагаем кнопки, потом текстовое поле между ними.

Я делал всё это поверх другого примера, так что можно заметить присутствие лишнего кода. Например, кнопка «Добавить таб». Она отображается только при переключении в режим выбора таба, в нашем же случае она просто скрыта.

Добавляем аниматор

Сначала добавим параметр, который будет меняться во время анимации. Не будем напрямую изменять размер UrlBar’а из Animator’а, а введём переменную, которая будет отображать текущий прогресс анимации в процентах.

Мы собираемся использовать ObjectAnimator, так что нужно добавить getter и setter для нашего параметра, однако, если minSdkVersion >= 14, то, чтобы избежать рефлексии, лучше создать поле класса Property для этого.

Теперь добавим 2 inner-класса и 2 поля для старта анимации.

Не забудем зарегистрировать наш OnFocusChangeListener в initializeViews!

На этом шаге логика работы непосредственно механизма анимации закончена, осталась визуальная составляющая, но сначала зазберёмся что, зачем и почему.

1. При изменении фокуса мы создаём ObjectAnimator, который пошагово изменяет переменную, обозначающую процент получения фокуса полем.
2. На каждом шаге вызывается invalidate() для ViewGroup. Данный метод не приводит к переразметке, он только перерисовывает компонент.

Процесс получения фокуса UrlBar’ом будет происходить следующим образом:

1. Скрываем все остальные элементы чтобы они не мешали отрисовке анимации (в нашем случае это кнопка переключения табов).
2. Вызываем requestLayout() чтобы после завершения анимации реальные границы UrlBar’а совпадали с наблюдаемыми (помните, что после вызова requestLayout() методы onMeasure+onLayout могут быть вызваны с задержкой!).
3. Начинаем пошагово менять процент выполнения анимации, вызывая на каждом шаге invalidate().
4. Вручную на каждом шаге высчитываем границы UrlBar’а для текущего процента и перерисовываем его.

При потере фокуса UrlBar’ом скрывать элементы и вызывать requestLayout() нужно наоборот, в конце работы анимации. Также, введём переменную для отключения этапа разметки, и не забудем добавить изменения в методы onMeasure и onLayout:

Готовимся к рисованию

Чтобы посчитать размер UrlBar’а на каждом шаге нам нужно знать его начальный и конечный размер. Добавим 2 переменные, в которые будем запоминать этот размер и в очередной раз немного поменяем onLayout:

Рисуем!

Помните, непосредственно во время анимации реальный размер UrlBar’а не меняется, это происходит либо в начале, либо в конце анимации, а по-умолчанию отрисовывает он себя в соответствии с границами, полученными на этапе разметки. Таким образом, во время анимации реальный размер компонента больше наблюдаемого. Чтобы уменьшить в этой ситуации наблюдаемый размер при отрисовке UrlBar’а воспользуемся хитростью — будем делать clipRect на canvas’е.

Ещё одна хитрость заключается в том, чтобы убрать фон у UrlBar’а и отрисовывать его вручную.

Немножечко меняем разметку.

Вводим переменную для отрисовки фона.

И, наконец, отрисовка! Добавим в метод drawChild(Canvas, View, long) условие для UrlBar’а:

Всё готово, можно запускать и смотреть:

Заключение

Принимаясь за работу, я ожидал, что задача окажется пустяковой и я справлюсь с ней буквально за один вечер. В который раз я натыкаюсь на эти грабли. Если у вас есть другие варианты реализации или замечания к текущей — обязательно поделитесь ими в комментариях.

Я же искренне надеюсь, что данный пример окажется для кого-то полезным. Удачи и да прибудет с вами плавная анимация!

Источник

Android activity change size

The default value of this attribute is false . android:allowTaskReparenting Whether or not the activity can move from the task that started it to the task it has an affinity for when that task is next brought to the front — » true » if it can move, and » false » if it must remain with the task where it started.

If this attribute is not set, the value set by the corresponding allowTaskReparenting attribute of the element applies to the activity. The default value is » false «.

Normally when an activity is started, it’s associated with the task of the activity that started it and it stays there for its entire lifetime. You can use this attribute to force it to be re-parented to the task it has an affinity for when its current task is no longer displayed. Typically, it’s used to cause the activities of an application to move to the main task associated with that application.

For example, if an e-mail message contains a link to a web page, clicking the link brings up an activity that can display the page. That activity is defined by the browser application, but is launched as part of the e-mail task. If it’s reparented to the browser task, it will be shown when the browser next comes to the front, and will be absent when the e-mail task again comes forward.

The affinity of an activity is defined by the taskAffinity attribute. The affinity of a task is determined by reading the affinity of its root activity. Therefore, by definition, a root activity is always in a task with the same affinity. Since activities with » singleTask » or » singleInstance » launch modes can only be at the root of a task, re-parenting is limited to the » standard » and » singleTop » modes. (See also the launchMode attribute.)

android:alwaysRetainTaskState Whether or not the state of the task that the activity is in will always be maintained by the system — » true » if it will be, and » false » if the system is allowed to reset the task to its initial state in certain situations. The default value is » false «. This attribute is meaningful only for the root activity of a task; it’s ignored for all other activities.

Normally, the system clears a task (removes all activities from the stack above the root activity) in certain situations when the user re-selects that task from the home screen. Typically, this is done if the user hasn’t visited the task for a certain amount of time, such as 30 minutes.

However, when this attribute is » true «, users will always return to the task in its last state, regardless of how they get there. This is useful, for example, in an application like the web browser where there is a lot of state (such as multiple open tabs) that users would not like to lose.

android:autoRemoveFromRecents Whether or not tasks launched by activities with this attribute remains in the overview screen until the last activity in the task is completed. If true , the task is automatically removed from the overview screen. This overrides the caller’s use of FLAG_ACTIVITY_RETAIN_IN_RECENTS . It must be a boolean value, either » true » or » false «. android:banner A drawable resource providing an extended graphical banner for its associated item. Use with the tag to supply a default banner for a specific activity, or with the tag to supply a banner for all application activities.

The system uses the banner to represent an app in the Android TV home screen. Since the banner is displayed only in the home screen, it should only be specified by applications with an activity that handles the CATEGORY_LEANBACK_LAUNCHER intent.

This attribute must be set as a reference to a drawable resource containing the image (for example «@drawable/banner» ). There is no default banner.

See Provide a home screen banner in Get Started with TV Apps for more information.

android:clearTaskOnLaunch Whether or not all activities will be removed from the task, except for the root activity, whenever it is re-launched from the home screen — » true » if the task is always stripped down to its root activity, and » false » if not. The default value is » false «. This attribute is meaningful only for activities that start a new task (the root activity); it’s ignored for all other activities in the task.

When the value is » true «, every time users start the task again, they are brought to its root activity regardless of what they were last doing in the task and regardless of whether they used the Back or Home button to leave it. When the value is » false «, the task may be cleared of activities in some situations (see the alwaysRetainTaskState attribute), but not always.

Suppose, for example, that someone launches activity P from the home screen, and from there goes to activity Q. The user next presses Home, and then returns to activity P. Normally, the user would see activity Q, since that is what they were last doing in P’s task. However, if P set this flag to » true «, all of the activities on top of it (Q in this case) would be removed when the user launched activity P from the home screen. So the user would see only P when returning to the task.

If this attribute and allowTaskReparenting are both » true «, any activities that can be re-parented are moved to the task they share an affinity with; the remaining activities are then dropped, as described above.

This attribute is ignored if FLAG_ACTIVITY_RESET_TASK_IF_NEEDED is not set.

Requests the activity to be displayed in wide color gamut mode on compatible devices. In wide color gamut mode, a window can render outside of the SRGB gamut to display more vibrant colors. If the device doesn’t support wide color gamut rendering, this attribute has no effect. For more information about rendering in wide color mode, see Enhancing Graphics with Wide Color Content.

android:configChanges Lists configuration changes that the activity will handle itself. When a configuration change occurs at runtime, the activity is shut down and restarted by default, but declaring a configuration with this attribute will prevent the activity from being restarted. Instead, the activity remains running and its onConfigurationChanged() method is called.

Note: Using this attribute should be avoided and used only as a last resort. Please read Handling Runtime Changes for more information about how to properly handle a restart due to a configuration change.

Any or all of the following strings are valid values for this attribute. Multiple values are separated by ‘ | ‘ — for example, » locale|navigation|orientation «.

Value	Description
» density «	The display density has changed — the user might have specified a different display scale, or a different display might now be active. Added in API level 24.
» fontScale «	The font scaling factor has changed — the user has selected a new global font size.
» keyboard «	The keyboard type has changed — for example, the user has plugged in an external keyboard.
» keyboardHidden «	The keyboard accessibility has changed — for example, the user has revealed the hardware keyboard.
» layoutDirection «	The layout direction has changed — for example, changing from left-to-right (LTR) to right-to-left (RTL). Added in API level 17.
» locale «	The locale has changed — the user has selected a new language that text should be displayed in.
» mcc «	The IMSI mobile country code (MCC) has changed — a SIM has been detected and updated the MCC.
» mnc «	The IMSI mobile network code (MNC) has changed — a SIM has been detected and updated the MNC.
» navigation «	The navigation type (trackball/dpad) has changed. (This should never normally happen.)
» orientation «	The screen orientation has changed — the user has rotated the device. Note: If your application targets Android 3.2 (API level 13) or higher, then you should also declare the «screenSize» and «screenLayout» configurations, because they might also change when a device switches between portrait and landscape orientations.
» screenLayout «	The screen layout has changed — a different display might now be active.
» screenSize «	The current available screen size has changed. This represents a change in the currently available size, relative to the current aspect ratio, so will change when the user switches between landscape and portrait. Added in API level 13.
» smallestScreenSize «	The physical screen size has changed. This represents a change in size regardless of orientation, so will only change when the actual physical screen size has changed such as switching to an external display. A change to this configuration corresponds to a change in the smallestWidth configuration. Added in API level 13.
» touchscreen «	The touchscreen has changed. (This should never normally happen.)
» uiMode «	The user interface mode has changed — the user has placed the device into a desk or car dock, or the night mode has changed. For more information about the different UI modes, see UiModeManager . Added in API level 8. All of these configuration changes can impact the resource values seen by the application. Therefore, when onConfigurationChanged() is called, it will generally be necessary to again retrieve all resources (including view layouts, drawables, and so on) to correctly handle the change. Note: To handle all Multi-Window related configuration changes use both «screenLayout» and «smallestScreenSize» . Multi-Window is supported in Android 7.0 (API level 24) or higher. Whether or not the activity is direct-boot aware; that is, whether or not it can run before the user unlocks the device. Note: During Direct Boot, an activity in your application can only access the data that is stored in device protected storage. The default value is «false» . android:documentLaunchMode Specifies how a new instance of an activity should be added to a task each time it is launched. This attribute permits the user to have multiple documents from the same application appear in the overview screen. This attribute has four values which produce the following effects when the user opens a document with the application: Value Description » intoExisting « The system searches for a task whose base intent’s ComponentName and data URI match those of the launching intent. If the system finds such a task, the system clears the task, and restarts with the root activity receiving a call to onNewIntent(android.content.Intent) . If the system does not find such a task, the system creates a new task. » always « The activity creates a new task for the document, even if the document is already opened. This is the same as setting both the FLAG_ACTIVITY_NEW_DOCUMENT and FLAG_ACTIVITY_MULTIPLE_TASK flags. » none « The activity does not create a new task for the activity. This is the default value, which creates a new task only when FLAG_ACTIVITY_NEW_TASK is set. The overview screen treats the activity as it would by default: it displays a single task for the app, which resumes from whatever activity the user last invoked. » never « This activity is not launched into a new document even if the Intent contains FLAG_ACTIVITY_NEW_DOCUMENT . Setting this overrides the behavior of the FLAG_ACTIVITY_NEW_DOCUMENT and FLAG_ACTIVITY_MULTIPLE_TASK flags, if either of these are set in the activity, and the overview screen displays a single task for the app, which resumes from whatever activity the user last invoked. Note: For values other than » none » and » never » the activity must be defined with launchMode=»standard» . If this attribute is not specified, documentLaunchMode=»none» is used. android:enabled Whether or not the activity can be instantiated by the system — «true» if it can be, and » false » if not. The default value is » true «. android:excludeFromRecents Whether or not the task initiated by this activity should be excluded from the list of recently used applications, the overview screen. That is, when this activity is the root activity of a new task, this attribute determines whether the task should not appear in the list of recent apps. Set » true » if the task should be excluded from the list; set » false » if it should be included. The default value is » false «. android:exported This element sets whether the activity can be launched by components of other applications: If » true «, the activity is accessible to any app, and is launchable by its exact class name. If » false «, the activity can be launched only by components of the same application, applications with the same user ID, or privileged system components. This is the default value when there are no intent filters. If an activity in your app includes intent filters, set this element to » true » to allow other apps to start it. For example, if the activity is the main activity of the app and includes the category » android.intent.category.LAUNCHER «. If this element is set to » false » and an app tries to start the activity, the system throws an ActivityNotFoundException . This attribute is not the only way to limit an activity’s exposure to other applications. Permissions can also be used to limit the external entities that can invoke the activity (see the permission attribute). android:finishOnTaskLaunch Whether or not an existing instance of the activity should be shut down (finished), except for the root activity, whenever the user again launches its task (chooses the task on the home screen) — » true » if it should be shut down, and » false » if not. The default value is » false «. If this attribute and allowTaskReparenting are both » true «, this attribute trumps the other. The affinity of the activity is ignored. The activity is not re-parented, but destroyed. This attribute is ignored if FLAG_ACTIVITY_RESET_TASK_IF_NEEDED isn’t set. android:hardwareAccelerated Whether or not hardware-accelerated rendering should be enabled for this Activity — » true » if it should be enabled, and » false » if not. The default value is » false «. Starting from Android 3.0, a hardware-accelerated OpenGL renderer is available to applications, to improve performance for many common 2D graphics operations. When the hardware-accelerated renderer is enabled, most operations in Canvas, Paint, Xfermode, ColorFilter, Shader, and Camera are accelerated. This results in smoother animations, smoother scrolling, and improved responsiveness overall, even for applications that do not explicitly make use the framework’s OpenGL libraries. Because of the increased resources required to enable hardware acceleration, your app will consume more RAM. Note that not all of the OpenGL 2D operations are accelerated. If you enable the hardware-accelerated renderer, test your application to ensure that it can make use of the renderer without errors. android:icon An icon representing the activity. The icon is displayed to users when a representation of the activity is required on-screen. For example, icons for activities that initiate tasks are displayed in the launcher window. The icon is often accompanied by a label (see the android:label attribute). This attribute must be set as a reference to a drawable resource containing the image definition. If it is not set, the icon specified for the application as a whole is used instead (see the element’s icon attribute). android:immersive Sets the immersive mode setting for the current activity. If the android:immersive attribute is set to true in the app’s manifest entry for this activity, the ActivityInfo.flags member always has its FLAG_IMMERSIVE bit set, even if the immersive mode is changed at runtime using the setImmersive() method. android:label A user-readable label for the activity. The label is displayed on-screen when the activity must be represented to the user. It’s often displayed along with the activity icon. If this attribute is not set, the label set for the application as a whole is used instead (see the element’s label attribute). The label should be set as a reference to a string resource, so that it can be localized like other strings in the user interface. However, as a convenience while you’re developing the application, it can also be set as a raw string. android:launchMode An instruction on how the activity should be launched. There are four modes that work in conjunction with activity flags ( FLAG_ACTIVITY_* constants) in Intent objects to determine what should happen when the activity is called upon to handle an intent. They are: » standard » » singleTop » » singleTask » » singleInstance « The default mode is » standard «. As shown in the table below, the modes fall into two main groups, with » standard » and » singleTop » activities on one side, and » singleTask » and » singleInstance » activities on the other. An activity with the » standard » or » singleTop » launch mode can be instantiated multiple times. The instances can belong to any task and can be located anywhere in the activity stack. Typically, they’re launched into the task that called startActivity() (unless the Intent object contains a FLAG_ACTIVITY_NEW_TASK instruction, in which case a different task is chosen — see the taskAffinity attribute). In contrast, » singleTask » and » singleInstance » activities can only begin a task. They are always at the root of the activity stack. Moreover, the device can hold only one instance of the activity at a time — only one such task. The » standard » and » singleTop » modes differ from each other in just one respect: Every time there’s a new intent for a » standard » activity, a new instance of the class is created to respond to that intent. Each instance handles a single intent. Similarly, a new instance of a » singleTop » activity may also be created to handle a new intent. However, if the target task already has an existing instance of the activity at the top of its stack, that instance will receive the new intent (in an onNewIntent() call); a new instance is not created. In other circumstances — for example, if an existing instance of the » singleTop » activity is in the target task, but not at the top of the stack, or if it’s at the top of a stack, but not in the target task — a new instance would be created and pushed on the stack. Similarly, if you navigate up to an activity on the current stack, the behavior is determined by the parent activity’s launch mode. If the parent activity has launch mode singleTop (or the up intent contains FLAG_ACTIVITY_CLEAR_TOP ), the parent is brought to the top of the stack, and its state is preserved. The navigation intent is received by the parent activity’s onNewIntent() method. If the parent activity has launch mode standard (and the up intent does not contain FLAG_ACTIVITY_CLEAR_TOP ), the current activity and its parent are both popped off the stack, and a new instance of the parent activity is created to receive the navigation intent. The » singleTask » and » singleInstance » modes also differ from each other in only one respect: A » singleTask » activity allows other activities to be part of its task. It’s always at the root of its task, but other activities (necessarily » standard » and » singleTop » activities) can be launched into that task. A » singleInstance » activity, on the other hand, permits no other activities to be part of its task. It’s the only activity in the task. If it starts another activity, that activity is assigned to a different task — as if FLAG_ACTIVITY_NEW_TASK was in the intent. Use Cases Launch Mode Multiple Instances? Comments Normal launches for most activities » standard « Yes Default. The system always creates a new instance of the activity in the target task and routes the intent to it. » singleTop « Conditionally If an instance of the activity already exists at the top of the target task, the system routes the intent to that instance through a call to its onNewIntent() method, rather than creating a new instance of the activity. Specialized launches (not recommended for general use) » singleTask « No The system creates the activity at the root of a new task and routes the intent to it. However, if an instance of the activity already exists, the system routes the intent to existing instance through a call to its onNewIntent() method, rather than creating a new one. » singleInstance « No Same as » singleTask» , except that the system doesn’t launch any other activities into the task holding the instance. The activity is always the single and only member of its task. As shown in the table above, standard is the default mode and is appropriate for most types of activities. SingleTop is also a common and useful launch mode for many types of activities. The other modes — singleTask and singleInstance — are not appropriate for most applications , since they result in an interaction model that is likely to be unfamiliar to users and is very different from most other applications. Regardless of the launch mode that you choose, make sure to test the usability of the activity during launch and when navigating back to it from other activities and tasks using the Back button. For more information on launch modes and their interaction with Intent flags, see the Tasks and Back Stack document. android:lockTaskMode Determines how the system presents this activity when the device is running in lock task mode. Android can run tasks in an immersive, kiosk-like fashion called lock task mode. When the system runs in lock task mode, device users typically can’t see notifications, access non-allowlisted apps, or return to the home screen (unless the Home app is allowlisted). Only apps that have been allowlisted by a device policy controller (DPC) can run when the system is in lock task mode. System and privileged apps, however, can run in lock task mode without being allowlisted. The value can be any one of the following R.attr.lockTaskMode string values: Tasks don’t launch into lockTask mode, and the device user can’t pin these tasks from the overview screen. Note: This mode is only available to system and privileged applications. Non-privileged apps with this value are treated as normal . Tasks rooted at this activity always launch into lock task mode. If the system is already in lock task mode when this task is launched then the new task are launched on top of the current task. Tasks launched in this mode can exit lock task mode by calling finish() . Note: This mode is only available to system and privileged applications. Non-privileged apps with this value are treated as normal . This attribute was introduced in API Level 23. android:maxRecents The maximum number of tasks rooted at this activity in the overview screen. When this number of entries is reached, the system removes the least-recently used instance from the overview screen. Valid values are 1 through 50 (25 on low memory devices); zero is invalid. This must be an integer value, such as 50. The default value is 16. android:maxAspectRatio The maximum aspect ratio the activity supports. If the app runs on a device with a wider aspect ratio, the system automatically letterboxes the app, leaving portions of the screen unused so the app can run at its specified maximum aspect ratio. Maximum aspect ratio is expressed as the decimal form of the quotient of the device’s longer dimension divided by its shorter dimension. For example, if the maximum aspect ratio is 7:3, set the value of this attribute to 2.33. On non-wearable devices, the value of this attribute needs to be 1.33 or greater. On wearable devices, it must be 1.0 or greater. Otherwise, the system ignores the set value. Note: This attribute is ignored if the activity has resizeableActivity set to true, since that means your activity supports any size. For more information about this attribute, see Supporting Multiple Screens. android:multiprocess Whether an instance of the activity can be launched into the process of the component that started it — » true » if it can be, and » false » if not. The default value is » false «. Normally, a new instance of an activity is launched into the process of the application that defined it, so all instances of the activity run in the same process. However, if this flag is set to » true «, instances of the activity can run in multiple processes, allowing the system to create instances wherever they are used (provided permissions allow it), something that is almost never necessary or desirable. android:name The name of the class that implements the activity, a subclass of Activity . The attribute value should be a fully qualified class name (such as, » com.example.project.ExtracurricularActivity «). However, as a shorthand, if the first character of the name is a period (for example, » .ExtracurricularActivity «), it is appended to the package name specified in the element. Once you publish your application, you should not change this name (unless you’ve set android:exported=»false» ). There is no default. The name must be specified. android:noHistory Whether or not the activity should be removed from the activity stack and finished (its finish() method called) when the user navigates away from it and it’s no longer visible on screen — » true » if it should be finished, and » false » if not. The default value is » false «. A value of » true » means that the activity will not leave a historical trace. It will not remain in the activity stack for the task, so the user will not be able to return to it. In this case, onActivityResult() is never called if you start another activity for a result from this activity. This attribute was introduced in API Level 3. android:parentActivityName The class name of the logical parent of the activity. The name here must match the class name given to the corresponding element’s android:name attribute. The system reads this attribute to determine which activity should be started when the user presses the Up button in the action bar. The system can also use this information to synthesize a back stack of activities with TaskStackBuilder . To support API levels 4 — 16, you can also declare the parent activity with a element that specifies a value for «android.support.PARENT_ACTIVITY» . For example: For more information about declaring the parent activity to support Up navigation, read Providing Up Navigation. This attribute was introduced in API Level 16. Defines how an instance of an activity is preserved within a containing task across device restarts. If the root activity of a task sets this attribute’s value to persistRootOnly , then only the root activity is preserved. Otherwise, the activities that are higher up the task’s back stack are examined; any of these activities that set this attribute’s value to persistAcrossReboots are preserved. If you use this attribute, you must set its value to one of the following: Value Description «normal» Default value. This is the default value. Tasks don’t launch into lock task mode but can be placed there by calling startLockTask() . «never» «if_whitelisted» If the DPC authorizes this package using DevicePolicyManager.setLockTaskPackages() , then this mode is identical to always , except that the activity needs to call stopLockTask() before being able to finish if it is the last locked task. If the DPC does not authorize this package then this mode is identical to normal . «always» Value Description persistRootOnly Default value. When the system restarts, the activity task is preserved, but only the root activity’s launching intent is used. When your app’s launching intent loads your app’s root activity, the activity doesn’t receive a PersistableBundle object. Therefore, don’t use onSaveInstanceState() to preserve the state of your app’s root activity across a device restart. Note: This attribute value affects your app’s behavior only if it’s set on your app’s root activity. This activity’s state is preserved, along with the state of each activity higher up the back stack that has its own persistableMode attribute set to persistAcrossReboots . If an activity doesn’t have a persistableMode attribute that is set to persistAcrossReboots , or if it’s launched using the Intent.FLAG_ACTIVITY_NEW_DOCUMENT flag, then that activity, along with all activities higher up the back stack, aren’t preserved. When an intent loads an activity whose persistableMode attribute is set to persistAcrossReboots in your app, the activity receives a PersistableBundle object in its onCreate() method. Therefore, you can use onSaveInstanceState() to preserve the state of an activity across a device restart as long as its persistableMode attribute is set to persistAcrossReboots . Note: This attribute value affects your app’s behavior even if it’s set on an activity other than your app’s root activity. The activity’s state isn’t preserved. Note: This attribute value affects your app’s behavior only if it’s set on your app’s root activity. This attribute was introduced in API level 21. android:permission The name of a permission that clients must have to launch the activity or otherwise get it to respond to an intent. If a caller of startActivity() or startActivityForResult() has not been granted the specified permission, its intent will not be delivered to the activity. If this attribute is not set, the permission set by the element’s permission attribute applies to the activity. If neither attribute is set, the activity is not protected by a permission. For more information on permissions, see the Permissions section in the introduction and another document, Security and Permissions. android:process The name of the process in which the activity should run. Normally, all components of an application run in a default process name created for the application and you do not need to use this attribute. But if necessary, you can override the default process name with this attribute, allowing you to spread your app components across multiple processes. If the name assigned to this attribute begins with a colon (‘:’), a new process, private to the application, is created when it’s needed and the activity runs in that process. If the process name begins with a lowercase character, the activity will run in a global process of that name, provided that it has permission to do so. This allows components in different applications to share a process, reducing resource usage. The element’s process attribute can set a different default process name for all components. android:relinquishTaskIdentity Whether or not the activity relinquishes its task identifiers to an activity above it in the task stack. A task whose root activity has this attribute set to » true » replaces the base Intent with that of the next activity in the task. If the next activity also has this attribute set to » true » then it will yield the base Intent to any activity that it launches in the same task. This continues for each activity until an activity is encountered which has this attribute set to » false «. The default value is » false «. This attribute set to » true » also permits the activity’s use of the ActivityManager.TaskDescription to change labels, colors and icons in the overview screen. Specifies whether the app supports multi-window mode. You can set this attribute in either the or element. If you set this attribute to true, the user can launch the activity in split-screen and free-form modes. If you set the attribute to false, the app can’t be tested or optimized for a multi-window environment. The system could still put the activity in multi-window mode with compatibility mode applied. Setting this attribute to true also doesn’t guarantee that there will be no other apps in multi-window mode visible on screen (such as picture-in-picture) or on other displays. Therefore, setting this flag does not ensure that your app has exclusive resource access. If your app targets API level 24 or higher, but you do not specify a value for this attribute, the attribute’s value defaults to true. If your app targets API level 31 or higher, this attribute works differently on small and large screens: Large screens (sw >= 600dp): All apps support multi-window mode. The attribute indicates whether an app can be resized (not whether the app supports multi-window mode). If resizeableActivity=»false» , the app is put into compatibility mode when necessary to conform to display dimensions. Small screens (sw resizeableActivity=»true» and the minimum width and minimum height of the activity are within the multi-window requirements, the app supports multi-window mode. If resizeableActivity=»false» , the app does not support multi-window mode regardless of the activity minimum width and height. Note: Device manufacturers can override the API level 31 behavior. This attribute was added in API level 24. Note: A task’s root activity value is applied to all additional activities launched in the task. That is, if the root activity of a task is resizable then the system treats all other activities in the task as resizable. If the root activity is not resizable, the other activities in the task are not resizable. android:screenOrientation The orientation of the activity’s display on the device. The system ignores this attribute if the activity is running in multi-window mode. The value can be any one of the following strings: » unspecified « The default value. The system chooses the orientation. The policy it uses, and therefore the choices made in specific contexts, may differ from device to device. » behind « The same orientation as the activity that’s immediately beneath it in the activity stack. » landscape « Landscape orientation (the display is wider than it is tall). » portrait « Portrait orientation (the display is taller than it is wide). » reverseLandscape « Landscape orientation in the opposite direction from normal landscape. Added in API level 9. » reversePortrait « Portrait orientation in the opposite direction from normal portrait. Added in API level 9. » sensorLandscape « Landscape orientation, but can be either normal or reverse landscape based on the device sensor. The sensor is used even if the user has locked sensor-based rotation. Added in API level 9. » sensorPortrait « Portrait orientation, but can be either normal or reverse portrait based on the device sensor. The sensor is used even if the user has locked sensor-based rotation. Added in API level 9. » userLandscape « Landscape orientation, but can be either normal or reverse landscape based on the device sensor and the user’s preference. Added in API level 18. » userPortrait « Portrait orientation, but can be either normal or reverse portrait based on the device sensor and the user’s preference. Added in API level 18. » sensor « The orientation is determined by the device orientation sensor. The orientation of the display depends on how the user is holding the device; it changes when the user rotates the device. Some devices, though, will not rotate to all four possible orientations, by default. To allow all four orientations, use «fullSensor» The sensor is used even if the user locked sensor-based rotation. » fullSensor « The orientation is determined by the device orientation sensor for any of the 4 orientations. This is similar to «sensor» except this allows any of the 4 possible screen orientations, regardless of what the device will normally do (for example, some devices won’t normally use reverse portrait or reverse landscape, but this enables those). Added in API level 9. » nosensor « The orientation is determined without reference to a physical orientation sensor. The sensor is ignored, so the display will not rotate based on how the user moves the device. » user « The user’s current preferred orientation. » fullUser « If the user has locked sensor-based rotation, this behaves the same as user , otherwise it behaves the same as fullSensor and allows any of the 4 possible screen orientations. Added in API level 18. » locked « Locks the orientation to its current rotation, whatever that is. Added in API level 18. Note: When you declare one of the landscape or portrait values, it is considered a hard requirement for the orientation in which the activity runs. As such, the value you declare enables filtering by services such as Google Play so your application is available only to devices that support the orientation required by your activities. For example, if you declare either «landscape» , «reverseLandscape» , or «sensorLandscape» , then your application will be available only to devices that support landscape orientation. However, you should also explicitly declare that your application requires either portrait or landscape orientation with the element. For example, . This is purely a filtering behavior provided by Google Play (and other services that support it) and the platform itself does not control whether your app can be installed when a device supports only certain orientations. Whether or not the activity is shown when the device’s current user is different than the user who launched the activity. You can set this attribute to a literal value— «true» or «false» —or you can set the attribute to a resource or theme attribute that contains a boolean value. This attribute was added in API level 23. android:stateNotNeeded Whether or not the activity can be killed and successfully restarted without having saved its state — » true » if it can be restarted without reference to its previous state, and » false » if its previous state is required. The default value is » false «. Normally, before an activity is temporarily shut down to save resources, its onSaveInstanceState() method is called. This method stores the current state of the activity in a Bundle object, which is then passed to onCreate() when the activity is restarted. If this attribute is set to » true «, onSaveInstanceState() may not be called and onCreate() will be passed null instead of the Bundle — just as it was when the activity started for the first time. A » true » setting ensures that the activity can be restarted in the absence of retained state. For example, the activity that displays the home screen uses this setting to make sure that it does not get removed if it crashes for some reason. Specifies whether the activity supports Picture-in-Picture display. This attribute was added in API level 24. android:taskAffinity The task that the activity has an affinity for. Activities with the same affinity conceptually belong to the same task (to the same «application» from the user’s perspective). The affinity of a task is determined by the affinity of its root activity. The affinity determines two things — the task that the activity is re-parented to (see the allowTaskReparenting attribute) and the task that will house the activity when it is launched with the FLAG_ACTIVITY_NEW_TASK flag. By default, all activities in an application have the same affinity. You can set this attribute to group them differently, and even place activities defined in different applications within the same task. To specify that the activity does not have an affinity for any task, set it to an empty string. If this attribute is not set, the activity inherits the affinity set for the application (see the element’s taskAffinity attribute). The name of the default affinity for an application is the package name set by the element. android:theme A reference to a style resource defining an overall theme for the activity. This automatically sets the activity’s context to use this theme (see setTheme() , and may also cause «starting» animations prior to the activity being launched (to better match what the activity actually looks like). If this attribute is not set, the activity inherits the theme set for the application as a whole — from the element’s theme attribute. If that attribute is also not set, the default system theme is used. For more information, see the Styles and Themes developer guide. android:uiOptions Extra options for an activity’s UI. Must be one of the following values. Value Description «none» No extra UI options. This is the default. «splitActionBarWhenNarrow» Add a bar at the bottom of the screen to display action items in the app bar (also known as the action bar), when constrained for horizontal space (such as when in portrait mode on a handset). Instead of a small number of action items appearing in the app bar at the top of the screen, the app bar is split into the top navigation section and the bottom bar for action items. This ensures a reasonable amount of space is made available not only for the action items, but also for navigation and title elements at the top. Menu items are not split across the two bars; they always appear together. For more information about the app bar, see the Adding the App Bar training class. This attribute was added in API level 14. android:windowSoftInputMode How the main window of the activity interacts with the window containing the on-screen soft keyboard. The setting for this attribute affects two things: The state of the soft keyboard — whether it is hidden or visible — when the activity becomes the focus of user attention. The adjustment made to the activity’s main window — whether it is resized smaller to make room for the soft keyboard or whether its contents pan to make the current focus visible when part of the window is covered by the soft keyboard. The setting must be one of the values listed in the following table, or a combination of one » state. » value plus one » adjust. » value. Setting multiple values in either group — multiple » state. » values, for example — has undefined results. Individual values are separated by a vertical bar ( | ). For example: Values set here (other than » stateUnspecified » and » adjustUnspecified «) override values set in the theme. Value Description » stateUnspecified « The state of the soft keyboard (whether it is hidden or visible) is not specified. The system will choose an appropriate state or rely on the setting in the theme. This is the default setting for the behavior of the soft keyboard. » stateUnchanged « The soft keyboard is kept in whatever state it was last in, whether visible or hidden, when the activity comes to the fore. » stateHidden « The soft keyboard is hidden when the user chooses the activity — that is, when the user affirmatively navigates forward to the activity, rather than backs into it because of leaving another activity. » stateAlwaysHidden « The soft keyboard is always hidden when the activity’s main window has input focus. » stateVisible « The soft keyboard is made visible when the user chooses the activity — that is, when the user affirmatively navigates forward to the activity, rather than backs into it because of leaving another activity. » stateAlwaysVisible « The soft keyboard is visible when the window receives input focus. » adjustUnspecified « It is unspecified whether the activity’s main window resizes to make room for the soft keyboard, or whether the contents of the window pan to make the current focus visible on-screen. The system will automatically select one of these modes depending on whether the content of the window has any layout views that can scroll their contents. If there is such a view, the window will be resized, on the assumption that scrolling can make all of the window’s contents visible within a smaller area. This is the default setting for the behavior of the main window. » adjustResize « The activity’s main window is always resized to make room for the soft keyboard on screen. » adjustPan « The activity’s main window is not resized to make room for the soft keyboard. Rather, the contents of the window are automatically panned so that the current focus is never obscured by the keyboard and users can always see what they are typing. This is generally less desirable than resizing, because the user may need to close the soft keyboard to get at and interact with obscured parts of the window. This attribute was introduced in API Level 3. introduced in: API Level 1 for all attributes except for noHistory and windowSoftInputMode , which were added in API Level 3. see also: Content and code samples on this page are subject to the licenses described in the Content License. Java is a registered trademark of Oracle and/or its affiliates. Источник Читайте также:  Определение рекламных звонков андроид Оцените статью Вам также может понравиться Как деактивировать режим наушников на смартфоне с Android? Когда к мобильному устройству присоединены наушники Обзор игры Джелли-Джу для Android В последние годы популярность мобильных игр резко возросла Лучшие шахматные приложения для iOS и Android Нынешний читерский скандал в шахматном мире сейчас Что хотят увидеть пользователи от Android 5.0 Key Lime Pie ОС Google Android развивается, и по всему видимому Правообладателям Политика конфиденциальности Контакты