Поддержка многооконного режима

Многооконный режим позволяет нескольким приложениям одновременно использовать один и тот же экран. Приложения могут располагаться рядом или одно над другим (режим разделенного экрана), одно приложение может находиться в небольшом окне, накладываясь на другие приложения (режим «картинка в картинке»), а отдельные приложения — в отдельных перемещаемых окнах с изменяемым размером (режим оконного отображения рабочего стола).

Рисунок 1. Отображение двух приложений рядом в режиме разделенного экрана.

Инструкции по использованию режима разделенного экрана на телефонах можно найти в разделе «Одновременное использование двух приложений на телефоне Pixel» .

Функции многооконного режима, специфичные для каждой версии

Возможности многооконного режима зависят от версии Android и типа устройства:

  • В Android 7.0 (уровень API 24) был представлен режим разделенного экрана на устройствах с маленьким экраном и режим «картинка в картинке» на некоторых устройствах.

    • В режиме разделенного экрана на весь экран отображаются два приложения, либо рядом друг с другом, либо одно над другим. Пользователи могут перетаскивать разделительную полосу между двумя приложениями, чтобы увеличить одно приложение и уменьшить другое.

    • Режим «картинка в картинке» позволяет пользователям продолжать воспроизведение видео во время взаимодействия с другим приложением (см. раздел «Поддержка режима «картинка в картинке»» ).

    • Режим оконного отображения рабочего стола , в котором пользователи могут свободно изменять размер каждого окна, может быть включен производителями устройств с большими экранами.

      Вы можете настроить обработку многооконного режима вашим приложением, указав минимально допустимые размеры вашей активности. Вы также можете отключить многооконный режим для вашего приложения, установив параметр resizeableActivity="false" чтобы система всегда отображала ваше приложение в полноэкранном режиме.

  • Android 8.0 (уровень API 26) расширяет возможности режима «картинка в картинке» для устройств с небольшим экраном.

  • В Android 12 (уровень API 31) многооконный режим стал стандартным поведением.

    • На больших экранах ( средний или расширенный размер окна) платформа поддерживает все приложения в многооконном режиме независимо от конфигурации приложения. Если resizeableActivity="false" указывает на наличие флага `--sizeableActivity`, приложение при необходимости переключается в режим совместимости для адаптации к размерам экрана.

    • На небольших экранах ( с компактным размером окна) система проверяет minWidth и minHeight активности, чтобы определить, может ли активность работать в многооконном режиме. Если resizeableActivity="false" , приложение не сможет работать в многооконном режиме независимо от минимальной ширины и высоты.

  • Android 16 (уровень API 36) отменяет ограничения по ориентации экрана, соотношению сторон и возможности изменения размера.

    • На больших экранах (минимальная ширина >= 600dp) система игнорирует атрибуты манифеста и API среды выполнения, используемые для ограничения ориентации, соотношения сторон и возможности изменения размера приложения, оптимизируя пользовательский опыт на всех форм-факторах устройств.

      Чтобы узнать, как исключить игры из изменений Android 16, см. раздел «Исключения , касающиеся ориентации, соотношения сторон и возможности изменения размера приложений» .

Стратегии внедрения

Многооконный режим можно активировать несколькими способами.

Поддержка разделения экрана по инициативе пользователя.

  1. Откройте экран «Недавние записи».
  2. Проведите пальцем по экрану, чтобы открыть приложение.
  3. Нажмите на значок приложения в строке заголовка приложения.
  4. Выберите пункт меню «Разделенный экран» .
  5. Выберите другое приложение на экране «Недавние».

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

Программное разделение экрана (запуск рядом)

Если вашему приложению необходимо запустить другую активность в соседнем окне, используйте флаг намерения FLAG_ACTIVITY_LAUNCH_ADJACENT . В Android 12L (уровень API 32) и выше этот флаг позволяет приложению, работающему в полноэкранном режиме, перейти в режим разделенного экрана и запустить целевую активность в соседнем окне. FLAG_ACTIVITY_LAUNCH_ADJACENT был введен в Android 7.0 (уровень API 24).

Для запуска смежного действия используйте FLAG_ACTIVITY_LAUNCH_ADJACENT в сочетании с FLAG_ACTIVITY_NEW_TASK , например: 

fun openUrlInAdjacentWindow(url: String) {
    Intent(Intent.ACTION_VIEW).apply { data = Uri.parse(url)
       addFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT or Intent.FLAG_ACTIVITY_NEW_TASK)
    }.also { intent -> startActivity(intent) }
}

Встраивание действий (разделение действий в рамках одной задачи)

Встраивание действий позволяет приложениям, состоящим из нескольких действий, разделять действия в рамках одной и той же задачи приложения , например, для отображения списка и подробной информации на больших экранах. Встраивание действий, являющееся частью Jetpack WindowManager , позволяет определять правила конфигурации (например, правила разделения пар) с помощью XML или вызовов API, которые определяют, отображаются ли действия рядом или друг над другом. Для получения полной информации см. раздел «Встраивание действий» .

Жизненный цикл активности в многооконном режиме

Многооконный режим не изменяет жизненный цикл активности . Однако состояние возобновления работы приложений в нескольких окнах различается в разных версиях Android.

Множественное резюме

Android 10 (уровень API 29) и более поздние версии поддерживают функцию возобновления работы нескольких приложений одновременно — все приложения остаются в состоянии « RESUMED , когда устройство находится в многооконном режиме. Приложение может быть приостановлено, если поверх него находится прозрачное приложение или если приложение не может быть сфокусировано, например, если приложение находится в режиме «картинка в картинке» . Также возможно, что в данный момент ни одно приложение не имеет фокуса, например, если открыто меню уведомлений. Метод onStop() работает как обычно: он вызывается всякий раз, когда приложение убирается с экрана.

Функция многократного возобновления воспроизведения также доступна на некоторых устройствах под управлением Android 9 (уровень API 28). Чтобы включить функцию многократного возобновления воспроизведения на устройствах Android 9, добавьте следующие метаданные в манифест:

<meta-data android:name="android.allow_multiple_resumed_activities" android:value="true" />

Чтобы убедиться в том, что данное устройство поддерживает эти метаданные манифеста, обратитесь к техническим характеристикам устройства.

Android 9

В многооконном режиме на Android 9 (уровень API 28) и ниже в данный момент активна только та активность, с которой пользователь взаимодействовал в последний раз. Эта активность считается самой верхней и находится только в состоянии RESUMED . Все остальные видимые активности находятся в STARTED , но не RESUMED . Однако система присваивает этим видимым, но не возобновленным активностям более высокий приоритет, чем невидимым. Если пользователь взаимодействует с одной из видимых активностей, эта активность возобновляется, и ранее самая верхняя активность переходит в состояние STARTED .

Когда в рамках одного активного процесса приложения выполняется несколько действий, возобновляется действие с наивысшим z-порядком, а остальные приостанавливаются.

Изменения конфигурации

Когда пользователь переводит приложение в многооконный режим, система уведомляет об изменении конфигурации, как указано в разделе «Обработка изменений конфигурации» . Это также происходит, когда пользователь изменяет размер приложения или возвращает его в полноэкранный режим.

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

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

Эксклюзивный доступ к ресурсам

Для поддержки функции многократного возобновления используйте функцию обратного вызова жизненного цикла onTopResumedActivityChanged() .

Функция обратного вызова вызывается, когда активность занимает или теряет позицию в списке возобновившихся активностей, что важно, когда активность использует общий ресурс-синглтон, такой как микрофон или камера: 

override fun onTopResumedActivityChanged(topResumed: Boolean) {
    if (topResumed) {
        // Top resumed activity.
        // Can be a signal to re-acquire exclusive resources.
    } else {
        // No longer the top resumed activity.
    }
}

Следует отметить, что приложение может потерять ресурсы и по другим причинам, например, из-за удаления используемого оборудования.

В любом случае, приложение должно корректно обрабатывать события и изменения состояния, влияющие на доступные ресурсы.

Для приложений, использующих камеру, CameraManager.AvailabilityCallback#onCameraAccessPrioritiesChanged() подсказывает, что сейчас может быть подходящий момент для попытки получить доступ к камере. Этот метод доступен начиная с Android 10 (уровень API 29).

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

Рисунок 2. Камера в многооконном режиме.

Вашему приложению не обязательно освобождать камеру при потере фокуса. Например, вы можете захотеть продолжить предварительный просмотр камеры, пока пользователь взаимодействует с вновь активным приложением, работающим в фоновом режиме. Допустимо, чтобы ваше приложение продолжало использовать камеру, даже если оно не является приложением, работающим в фоновом режиме, но оно должно корректно обрабатывать случай разрыва соединения. Когда приложение, работающее в фоновом режиме, захочет использовать камеру, оно сможет её открыть, и ваше приложение потеряет к ней доступ. Ваше приложение сможет снова открыть камеру, когда вернёт фокус.

После того, как приложение получит обратный вызов CameraDevice.StateCallback#onDisconnected() , последующие вызовы на устройстве камеры будут генерировать исключение CameraAccessException .

Оконные метрики

В Android 11 (уровень API 30) были введены следующие методы WindowManager для определения границ приложений, работающих в многооконном режиме:

  • getCurrentWindowMetrics() : Возвращает объект WindowMetrics , отображающий текущее состояние окон в системе.
  • getMaximumWindowMetrics() : возвращает WindowMetrics для наибольшего потенциального состояния окон в системе.

Методы библиотеки Jetpack WindowManager computeCurrentWindowMetrics() и computeMaximumWindowMetrics() предлагают аналогичную функциональность, но с обратной совместимостью с уровнем API 14.

Чтобы получить метрики для дисплеев, отличных от текущего, выполните следующие действия (как показано в фрагменте кода):

  • Создать контекст отображения
  • Создайте контекст окна для отображения.
  • Получите WindowManager контекста окна.
  • Получите значение WindowMetrics , показывающее максимальную область отображения, доступную приложению.

val windowMetrics = context.createDisplayContext(display)
                           .createWindowContext(WindowManager.LayoutParams.TYPE_APPLICATION, null)
                           .getSystemService(WindowManager::class.java)
                           .maximumWindowMetrics

Устаревшие методы

Методы Display getSize() и getMetrics() были объявлены устаревшими в API уровня 30 в пользу новых методов WindowManager .

В Android 12 (уровень API 31) методы Display getRealSize() и getRealMetrics() объявлены устаревшими, а их поведение обновлено, чтобы оно больше соответствовало поведению метода getMaximumWindowMetrics() .

Настройка многооконного режима

Если ваше приложение ориентировано на Android 7.0 (уровень API 24) или выше, вы можете настроить, как и будут ли действия вашего приложения поддерживать многооконный режим. Вы можете задать атрибуты в манифесте для управления размером и расположением. Настройки атрибутов корневого действия применяются ко всем действиям в его стеке задач. Например, если корневое действие имеет android:resizeableActivity="true" , то все действия в стеке задач будут изменять размер. На некоторых больших устройствах, таких как Chromebook, ваше приложение может работать в окне с изменяемым размером, даже если вы укажете android:resizeableActivity="false" . Если это нарушит работу вашего приложения, вы можете использовать фильтры в Google Play , чтобы ограничить доступность вашего приложения на таких устройствах.

В Android 12 (уровень API 31) по умолчанию используется многооконный режим. На больших экранах ( средний или расширенный размер окна) все приложения работают в многооконном режиме независимо от конфигурации приложения. На маленьких экранах система проверяет параметры minWidth , minHeight и resizeableActivity для определения возможности работы приложения в многооконном режиме.

resizeableActivity

Установите этот атрибут в элементе <activity> или <application> вашего манифеста, чтобы включить или отключить многооконный режим для API уровня 30 и ниже: 

<application
  android:name=".MyActivity"
  android:resizeableActivity=["true" | "false"] />;

Если этому атрибуту присвоено значение true , активность может быть запущена в режиме разделенного экрана и в оконном режиме рабочего стола. Если атрибуту присвоено значение false , активность не поддерживает многооконный режим. Если значение равно false, и пользователь пытается запустить активность в многооконном режиме, активность занимает весь экран.

Если ваше приложение ориентировано на API уровня 24 или выше, но вы не указываете значение для этого атрибута, значение атрибута по умолчанию будет равно true.

Если ваше приложение ориентировано на API уровня 31 или выше, этот атрибут будет работать по-разному на маленьких и больших экранах:

  • Большие экраны ( средний или расширенный размер окна): Все приложения поддерживают многооконный режим. Атрибут указывает, можно ли изменять размер активности. Если resizeableActivity="false" , приложение при необходимости переходит в режим совместимости, чтобы соответствовать размерам экрана.
  • Для небольших экранов (класс компактных окон): если resizeableActivity="true" , а минимальная ширина и минимальная высота активности соответствуют требованиям многооконного режима, активность поддерживает многооконный режим. Если resizeableActivity="false" , активность не поддерживает многооконный режим независимо от минимальной ширины и высоты активности.

Если ваше приложение ориентировано на API уровня 36 или выше, этот атрибут игнорируется на дисплеях с минимальной шириной >= 600dp. Однако приложение полностью учитывает выбранное пользователем соотношение сторон (см. раздел «Переопределения для каждого приложения »).

Если вы разрабатываете игру, ознакомьтесь с разделом «Ориентация приложения, соотношение сторон и возможность изменения размера» , чтобы узнать, как исключить вашу игру из изменений Android 16 (уровень API 36).

supportsPictureInPicture

Укажите этот атрибут в узле <activity> вашего манифеста, чтобы указать, поддерживает ли активность режим "картинка в картинке". 

<activity
  android:name=".MyActivity"
  android:supportsPictureInPicture=["true" | "false"] />

configChanges

Чтобы самостоятельно обрабатывать изменения конфигурации многооконного режима, например, когда пользователь изменяет размер окна, добавьте атрибут android:configChanges в узел <activity> манифеста приложения, указав как минимум следующие значения: 

<activity
  android:name=".MyActivity"
  android:configChanges="screenSize | smallestScreenSize
      | screenLayout | orientation" />

После добавления android:configChanges ваши активности и фрагменты получают обратный вызов ` onConfigurationChanged() вместо уничтожения и повторного создания. Затем вы можете вручную обновлять представления, перезагружать ресурсы и выполнять другие необходимые операции.

<layout>

В Android 7.0 (уровень API 24) и выше элемент манифеста <layout> поддерживает несколько атрибутов, влияющих на поведение активности в многооконном режиме:

  • android:defaultHeight , android:defaultWidth : Высота и ширина активности по умолчанию при запуске в оконном режиме рабочего стола.

  • android:gravity : Начальное размещение активности при запуске в оконном режиме рабочего стола. Подходящие значения см. в классе Gravity .

  • android:minHeight , android:minWidth : Минимальная высота и минимальная ширина для активности как в режиме разделенного экрана, так и в оконном режиме рабочего стола. Если пользователь перемещает разделитель в режиме разделенного экрана, чтобы уменьшить размер активности ниже указанного минимума, система обрезает активность до размера, запрошенного пользователем.

Приведенный ниже код показывает, как задать размер и местоположение активности по умолчанию, а также ее минимальный размер при отображении в оконном режиме рабочего стола: 

<activity android:name=".MyActivity">
    <layout android:defaultHeight="500dp"
          android:defaultWidth="600dp"
          android:gravity="top|end|..."
          android:minHeight="450dp"
          android:minWidth="300dp" />
</activity>

Многооконный режим во время выполнения

Начиная с Android 7.0, система предлагает функциональность для поддержки приложений, способных работать в многооконном режиме.

Отключенные функции в многооконном режиме

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

Кроме того, некоторые параметры настройки системного интерфейса отключены. Например, приложения не могут скрыть строку состояния, если они работают в многооконном режиме (см. раздел «Управление видимостью системного интерфейса »).

Система игнорирует изменения атрибута android:screenOrientation .

Запросы и обратные вызовы в многооконном режиме

Класс Activity предоставляет следующие методы для поддержки многооконного режима:

  • isInMultiWindowMode() : Указывает, находится ли активность в многооконном режиме.

  • isInPictureInPictureMode() : Указывает, находится ли активность в режиме «картинка в картинке».

  • onMultiWindowModeChanged() : Система вызывает этот метод всякий раз, когда активность переходит в многооконный режим или выходит из него. Система передает методу значение true, если активность переходит в многооконный режим, или false, если активность выходит из многооконного режима.

  • onPictureInPictureModeChanged() : Система вызывает этот метод всякий раз, когда активность переходит в режим «картинка в картинке» или выходит из него. Система передает методу значение true, если активность переходит в режим «картинка в картинке», или false, если активность выходит из этого режима.

Класс Fragment предоставляет версии многих из этих методов; например, Fragment.onMultiWindowModeChanged() .

режим «картинка в картинке»

Чтобы перевести действие в режим «картинка в картинке», вызовите enterPictureInPictureMode() Этот метод не будет работать, если устройство не поддерживает режим «картинка в картинке». Дополнительную информацию см. в разделе «Добавление видео с использованием режима «картинка в картинке» (PiP)» .

Новые возможности в многооконном режиме

При запуске нового действия вы можете указать, что новое действие должно отображаться рядом с текущим, если это возможно. Используйте флаг намерения FLAG_ACTIVITY_LAUNCH_ADJACENT , который указывает системе попытаться создать новое действие в соседнем окне, чтобы два действия отображались на одном экране. Система прилагает все усилия для этого, но это не гарантирует успеха.

Если устройство находится в оконном режиме рабочего стола и вы запускаете новое действие, вы можете указать размеры и расположение нового действия на экране, вызвав метод ActivityOptions.setLaunchBounds() . Этот метод не оказывает никакого эффекта, если устройство не находится в многооконном режиме.

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

Android 12 (уровень API 31) позволяет приложениям разделять окно задачи между несколькими активностями. Вы определяете, как ваше приложение отображает свои активности — на весь экран, рядом или друг над другом — создавая XML-файл конфигурации или выполняя вызовы API Jetpack WindowManager.

Перетаскивание

Пользователи могут перетаскивать данные из одной активности в другую, когда обе активности отображаются на одном экране. (До Android 7.0 пользователи могли перетаскивать данные только в рамках одной активности.) Для быстрого добавления поддержки приема перетаскиваемого контента см. API DropHelper . Подробные инструкции по перетаскиванию см. в разделе «Включение перетаскивания» .

Многоэкземплярный

Каждое корневое действие имеет свою собственную задачу, которая отображается в отдельном окне. Чтобы запустить новый экземпляр вашего приложения в отдельном окне, запускайте новые действия с флагом FLAG_ACTIVITY_NEW_TASK . Вы можете комбинировать этот параметр с атрибутами многооконного режима , чтобы запросить определенное местоположение для нового окна. Например, приложение для покупок может отображать несколько смежных окон для сравнения товаров.

В Android 12 (уровень API 31) и выше можно запускать два экземпляра активности одновременно в одном окне задачи при встраивании активности .

Если вы хотите разрешить пользователям запускать другой экземпляр вашего приложения из панели запуска приложений или панели задач, установите android:resizeableActivity="true" в манифесте вашей активности запуска и не используйте режим запуска , который предотвращает запуск нескольких экземпляров. Например, активность singleInstancePerTask может быть запущена несколько раз в разных задачах, если установлен FLAG_ACTIVITY_MULTIPLE_TASK или FLAG_ACTIVITY_NEW_DOCUMENT .

В Android 15 (уровень API 35) и выше свойство PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI позволяет объявлять поддержку многоэкземплярного режима. Это свойство является явным сигналом для системного пользовательского интерфейса о предоставлении пользователю элементов управления для создания нескольких экземпляров приложения. Свойство не зависит от режима запуска, но должно использоваться только тогда, когда режим запуска активности или приложения совместим с этим свойством, например, когда режим запуска не singleInstance .

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

Проверка многооконного режима

Независимо от того, ориентировано ли ваше приложение на API уровня 24 или выше, вам следует проверить, как оно ведет себя в многооконном режиме, если пользователь попытается запустить его в многооконном режиме на устройстве под управлением Android 7.0 или выше.

Тестовые устройства

Многооконный режим поддерживаются устройствами под управлением Android 7.0 (уровень API 24) или выше.

Уровень API 23 или ниже

Когда пользователи пытаются использовать приложение в многооконном режиме, система принудительно изменяет размер приложения, если приложение не указало фиксированную ориентацию.

Если ваше приложение не указывает фиксированную ориентацию экрана, запустите его на устройстве под управлением Android 7.0 или выше и попробуйте перевести в режим разделенного экрана. Убедитесь, что пользовательский опыт приемлем при принудительном изменении размера окна приложения.

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

Уровни API от 24 до 30

Если ваше приложение ориентировано на уровни API от 24 до 30 и не отключает поддержку многооконного режима, проверьте следующее поведение как в режиме разделенного экрана, так и в оконном режиме рабочего стола:

  • Запустите приложение в полноэкранном режиме, затем переключитесь в многооконный режим, удерживая кнопку « Недавние» . Убедитесь, что переключение приложений происходит корректно.

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

  • Измените размер приложения в режиме разделенного экрана, перетаскивая разделитель экрана. Убедитесь, что приложение изменяет размер без сбоев и что необходимые элементы пользовательского интерфейса видны.

  • Если для вашего приложения указаны минимальные размеры, попробуйте изменить размер приложения так, чтобы размер его окна был меньше этих размеров. Убедитесь, что вам не удается изменить размер приложения до размеров меньше указанных минимальных размеров.

  • В ходе всех тестов убедитесь, что производительность вашего приложения приемлема. Например, проверьте, нет ли слишком большой задержки при обновлении пользовательского интерфейса после изменения размера окна приложения.

Уровень API 31 или выше

Если ваше приложение ориентировано на API уровня 31 или выше, а минимальная ширина и минимальная высота основного окна меньше или равны соответствующим размерам доступной области отображения, проверьте все параметры поведения, перечисленные для API уровней 24–30 .

Контрольный список тестов

Чтобы проверить производительность вашего приложения в многооконном режиме, попробуйте выполнить следующие действия. Эти действия следует выполнять как в режиме разделенного экрана, так и в оконном режиме рабочего стола, если не указано иное.

  • Вход и выход из многооконного режима.

  • Переключитесь с вашего приложения на другое и убедитесь, что оно корректно работает, когда оно видимо, но неактивно. Например, если ваше приложение воспроизводит видео, убедитесь, что воспроизведение видео продолжается, пока пользователь взаимодействует с другим приложением.

  • В режиме разделенного экрана попробуйте переместить разделитель экрана, чтобы увеличить и уменьшить размер вашего приложения. Попробуйте эти действия как в режиме «рядом», так и в режиме «один экран поверх другого». Убедитесь, что приложение не вылетает, основные функции отображаются, а изменение размера не занимает слишком много времени.

  • Выполните несколько операций изменения размера с небольшой периодичностью. Убедитесь, что ваше приложение не вылетает и не допускает утечек памяти. Инструмент Memory Profiler в Android Studio предоставляет информацию об использовании памяти вашим приложением (см. раздел «Проверка использования памяти вашим приложением с помощью Memory Profiler »).

  • Протестируйте приложение в различных конфигурациях окон и убедитесь, что оно работает корректно. Проверьте читаемость текста и убедитесь, что элементы пользовательского интерфейса не слишком малы для взаимодействия.

Поддержка многооконного режима отключена.

На уровнях API от 24 до 30, если вы отключили поддержку многооконного режима, установив параметр android:resizeableActivity="false" , вам следует запустить приложение на устройстве под управлением Android 7.0–11 и попытаться перевести приложение в режимы разделенного экрана и оконного режима рабочего стола. Убедитесь, что при этом приложение остается в полноэкранном режиме.

Дополнительные ресурсы

Для получения дополнительной информации о поддержке многооконного режима в Android см.:

Назад
Используйте классы размеров окон
Далее
Поддержка окон рабочего стола