Obsługa trybu wielu okien

Tryb wielu okien umożliwia korzystanie z kilku aplikacji jednocześnie na tym samym ekranie. Aplikacje mogą być wyświetlane obok siebie lub jedna nad drugą (tryb podzielonego ekranu), jedna aplikacja w małym oknie nakładającym się na inne aplikacje (tryb obrazu w obrazie) lub poszczególne aplikacje w oddzielnych, ruchomych oknach o zmienianym rozmiarze (tryb okien na komputerze).

Rysunek 1. Wyświetlaj 2 aplikacje obok siebie w trybie podzielonego ekranu.

Instrukcje dla użytkowników dotyczące włączania trybu podzielonego ekranu na telefonach znajdziesz w artykule Wyświetlanie dwóch aplikacji jednocześnie na telefonie Pixel.

Funkcje wielu okien w poszczególnych wersjach

Wygoda korzystania z wielu okien zależy od wersji Androida i typu urządzenia:

  • Android 7.0 (poziom interfejsu API 24) wprowadził tryb podzielonego ekranu na urządzeniach z małym ekranem i tryb obrazu w obrazie na wybranych urządzeniach.

    • Tryb podzielonego ekranu wypełnia ekran 2 aplikacjami, wyświetlając je obok siebie lub jedną nad drugą. Użytkownicy mogą przeciągnąć separator między aplikacjami, aby powiększyć jedną z nich i pomniejszyć drugą.

    • Tryb obrazu w obrazie umożliwia użytkownikom kontynuowanie odtwarzania filmu podczas korzystania z innej aplikacji (patrz Obsługa obrazu w obrazie).

    • Tryb okien na komputerze, w którym użytkownicy mogą dowolnie zmieniać rozmiar każdego działania, może być włączony przez producentów urządzeń z dużym ekranem.

      Możesz skonfigurować sposób obsługi trybu wielu okien przez aplikację, określając minimalne dopuszczalne wymiary aktywności. Możesz też wyłączyć tryb wielu okien w aplikacji, ustawiając wartość resizeableActivity="false", aby system zawsze wyświetlał aplikację na pełnym ekranie.

  • Android 8.0 (poziom 26 interfejsu API) rozszerza tryb obrazu w obrazie na urządzenia z małymi ekranami.

  • Android 12 (poziom 31 interfejsu API) sprawia, że tryb wielu okien jest standardowym zachowaniem.

    • Na dużych ekranach (średnia lub rozszerzona klasa rozmiaru okna) platforma obsługuje wszystkie aplikacje w trybie wielu okien niezależnie od konfiguracji aplikacji. Jeśli resizeableActivity="false", aplikacja jest w razie potrzeby przełączana w tryb zgodności, aby dostosować się do wymiarów wyświetlacza.

    • Na małych ekranach (klasa rozmiaru okna compact) system sprawdza minWidth i minHeight aktywności, aby określić, czy może ona działać w trybie wielu okien. Jeśli resizeableActivity="false", aplikacja nie może działać w trybie wielu okien niezależnie od minimalnej szerokości i wysokości.

  • Android 16 (poziom 36 interfejsu API) zastępuje ograniczenia dotyczące orientacji ekranu, proporcji i możliwości zmiany rozmiaru.

    • Na dużych ekranach (najmniejsza szerokość >= 600 dp) system ignoruje atrybuty manifestu i interfejsy API środowiska wykonawczego używane do ograniczania orientacji, współczynnika proporcji i możliwości zmiany rozmiaru aplikacji, optymalizując wrażenia użytkownika na wszystkich urządzeniach.

      Aby dowiedzieć się, jak wykluczyć gry ze zmian w Androidzie 16, zapoznaj się z sekcją Wyjątki dotyczące orientacji, proporcji i możliwości zmiany rozmiaru aplikacji.

Tryb podzielonego ekranu

Aby włączyć tryb podzielonego ekranu, użytkownicy muszą wykonać te czynności:

  1. Otwórz ekran ostatnich aplikacji.
  2. Przesuń aplikację, aby ją wyświetlić
  3. Kliknij ikonę aplikacji na pasku tytułu aplikacji.
  4. Wybierz opcję menu podzielonego ekranu.
  5. Wybierz inną aplikację na ekranie Ostatnie lub zamknij ten ekran i uruchom inną aplikację.

Aby wyjść z trybu podzielonego ekranu, przeciągnij separator okien do krawędzi ekranu – w górę lub w dół, w lewo lub w prawo.

Uruchom obok

Jeśli aplikacja musi uzyskać dostęp do treści za pomocą intencji, możesz użyć FLAG_ACTIVITY_LAUNCH_ADJACENT, aby otworzyć treści w sąsiednim oknie podzielonego ekranu.

FLAG_ACTIVITY_LAUNCH_ADJACENT został wprowadzony w Androidzie 7.0 (poziom interfejsu API 24), aby umożliwić aplikacjom działającym w trybie podzielonego ekranu uruchamianie działań w sąsiednim oknie.

Android 12L (API na poziomie 32) i nowsze rozszerzają definicję tego parametru, aby umożliwić aplikacjom działającym w trybie pełnoekranowym aktywowanie trybu podzielonego ekranu, a następnie uruchamianie aktywności w sąsiednim oknie.

Aby uruchomić sąsiednie działanie, użyj FLAG_ACTIVITY_LAUNCH_ADJACENT w połączeniu z FLAG_ACTIVITY_NEW_TASK, na przykład:

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) }
}

Cykl życia aktywności w trybie wielu okien

Tryb wielu okien nie zmienia cyklu życia aktywności. Jednak stan wznowienia aplikacji w wielu oknach różni się w zależności od wersji Androida.

Wielokrotne wznawianie

Android 10 (poziom interfejsu API 29) i nowsze wersje obsługują funkcję multi-resume – wszystkie aktywności pozostają w stanie RESUMED, gdy urządzenie jest w trybie wielu okien. Aktywność można wstrzymać, jeśli na jej wierzchu znajduje się przezroczysta aktywność lub jeśli nie można jej ustawić jako aktywnej, np. gdy jest ona w trybie obrazu w obrazie. Możliwe jest też, że w danym momencie żadna aktywność nie jest aktywna, np. gdy otwarte jest menu powiadomień. Metoda onStop() działa jak zwykle: jest wywoływana za każdym razem, gdy aktywność jest usuwana z ekranu.

Funkcja wielokrotnego wznawiania jest też dostępna na wybranych urządzeniach z Androidem 9 (interfejs API na poziomie 28). Aby włączyć funkcję wielu wznowień na urządzeniach z Androidem 9, dodaj te metadane do pliku manifestu:

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

Aby sprawdzić, czy dane urządzenie obsługuje te metadane pliku manifestu, zapoznaj się ze specyfikacją urządzenia.

Android 9

W trybie wielu okien na Androidzie 9 (API na poziomie 28) i starszych wersjach w danym momencie aktywna jest tylko ta aktywność, z którą użytkownik ostatnio wszedł w interakcję. Ta aktywność jest uznawana za najwyższą i jest jedyną aktywnością w stanie RESUMED. Wszystkie inne widoczne aktywności są STARTED, ale nie są RESUMED. System nadaje jednak tym widocznym, ale nie wznowionym aktywnościom wyższy priorytet niż aktywnościom, które nie są widoczne. Jeśli użytkownik wejdzie w interakcję z jedną z widocznych aktywności, zostanie ona wznowiona, a poprzednia aktywność na samej górze przejdzie w stan STARTED.

Jeśli w ramach jednego aktywnego procesu aplikacji występuje kilka aktywności, wznawiana jest aktywność o najwyższym porządku Z, a pozostałe są wstrzymywane.

Zmiany konfiguracji

Gdy użytkownik przełączy aplikację w tryb wielu okien, system powiadomi aktywność o zmianie konfiguracji zgodnie z opisem w sekcji Obsługa zmian konfiguracji. Dzieje się tak również wtedy, gdy użytkownik zmienia rozmiar aplikacji lub przywraca ją do trybu pełnoekranowego.

W zasadzie ta zmiana ma takie same konsekwencje dla cyklu życia aktywności jak w przypadku, gdy system powiadamia aplikację, że urządzenie zostało przełączone z orientacji pionowej na poziomą. Z tą różnicą, że zamiast tylko zamieniać wymiary aplikacji, są one zmieniane. Aktywność może sama obsłużyć zmianę konfiguracji lub aplikacja może zezwolić systemowi na zniszczenie aktywności i ponowne utworzenie jej z nowymi wymiarami.

Jeśli użytkownik zmienia rozmiar okna i powiększa je w dowolnym wymiarze, system zmienia rozmiar aktywności, aby dopasować ją do działania użytkownika, i w razie potrzeby wprowadza zmiany w konfiguracji. Jeśli aplikacja nie nadąża z rysowaniem w nowo odsłoniętych obszarach, system tymczasowo wypełnia te obszary kolorem określonym przez atrybut windowBackground lub przez domyślny atrybut stylu windowBackgroundFallback.

Dostęp do wyjątkowych zasobów

Aby obsługiwać funkcję wielu wznowień, użyj wywołania zwrotnego cyklu życia onTopResumedActivityChanged().

Wywołanie zwrotne jest wywoływane, gdy aktywność zyskuje lub traci pozycję najwyższej wznowionej aktywności, co jest ważne, gdy aktywność korzysta ze współdzielonego zasobu singleton, takiego jak mikrofon lub kamera:

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.
    }
}

Pamiętaj, że aplikacja może utracić zasoby z innych powodów, np. z powodu usunięcia wspólnego elementu sprzętu.

W każdym przypadku aplikacja powinna prawidłowo obsługiwać zdarzenia i zmiany stanu, które wpływają na dostępne zasoby.

W przypadku aplikacji, które korzystają z aparatu,CameraManager.AvailabilityCallback#onCameraAccessPrioritiesChanged() podaje wskazówkę, że może to być dobry moment na próbę uzyskania dostępu do aparatu. Ta metoda jest dostępna od Androida 10 (poziom interfejsu API 29).

Pamiętaj, że resizeableActivity=false nie gwarantuje wyłącznego dostępu do aparatu, ponieważ inne aplikacje korzystające z aparatu można otworzyć na innych wyświetlaczach.

Rysunek 2. Aparat w trybie wielu okien.

Aplikacja nie musi zwalniać aparatu, gdy traci fokus. Możesz na przykład chcieć kontynuować podgląd z kamery, gdy użytkownik wchodzi w interakcję z aplikacją, która została wznowiona i jest teraz na wierzchu. Aplikacja może nadal korzystać z kamery, gdy nie jest na wierzchu, ale musi prawidłowo obsługiwać przypadek odłączenia. Gdy aplikacja na samej górze będzie chciała użyć aparatu, może go otworzyć, a Twoja aplikacja straci do niego dostęp. Aplikacja może ponownie otworzyć aparat, gdy odzyska fokus.

Gdy aplikacja otrzyma wywołanie zwrotne CameraDevice.StateCallback#onDisconnected(), kolejne wywołania na urządzeniu z aparatem będą powodować błąd CameraAccessException.

Dane dotyczące okna

W Androidzie 11 (poziom interfejsu API 30) wprowadzono te WindowManager metody, które określają granice aplikacji działających w trybie wielu okien:

Metody biblioteki Jetpack WindowManager computeCurrentWindowMetrics() i computeMaximumWindowMetrics() oferują podobne funkcje, ale są zgodne wstecznie z interfejsem API na poziomie 14.

Aby uzyskać dane dotyczące wyświetlaczy innych niż bieżący, wykonaj te czynności (jak pokazano we fragmencie kodu):

  • Tworzenie kontekstu reklamy displayowej
  • Utwórz kontekst okna dla wyświetlacza.
  • Pobieranie WindowManager kontekstu okna
  • Uzyskaj WindowMetrics maksymalnego obszaru wyświetlania dostępnego dla aplikacji

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

Wycofane metody

Metody Display getSize() i getMetrics() zostały wycofane na poziomie API 30 na rzecz nowych metod WindowManager.

W Androidzie 12 (poziom API 31) metody Display getRealSize() i getRealMetrics() zostały wycofane, a ich działanie zostało zmienione, aby bardziej przypominało działanie metody getMaximumWindowMetrics().

Konfiguracja trybu wielu okien

Jeśli Twoja aplikacja jest kierowana na Androida 7.0 (API na poziomie 24) lub nowszego, możesz skonfigurować, w jaki sposób i czy aktywności aplikacji obsługują tryb wielu okien. W pliku manifestu możesz ustawić atrybuty, aby kontrolować zarówno rozmiar, jak i układ. Ustawienia atrybutów aktywności głównej mają zastosowanie do wszystkich aktywności w jej stosie zadań. Jeśli na przykład aktywność główna ma atrybut android:resizeableActivity="true", wszystkie aktywności w stosie zadań można zmieniać. Na niektórych większych urządzeniach, takich jak Chromebooki, aplikacja może działać w oknie o zmienianym rozmiarze, nawet jeśli określisz android:resizeableActivity="false". Jeśli to spowoduje nieprawidłowe działanie aplikacji, możesz użyć filtrów w Google Play, aby ograniczyć dostępność aplikacji na takich urządzeniach.

Android 12 (poziom 31 interfejsu API) domyślnie działa w trybie wielu okien. Na dużych ekranach (średnia lub rozwinięta klasa rozmiaru okna) wszystkie aplikacje działają w trybie wielu okien niezależnie od konfiguracji aplikacji. Na małych ekranach system sprawdza ustawienia minWidth, minHeight i resizeableActivity aktywności, aby określić, czy może ona działać w trybie wielu okien.

resizeableActivity

Aby włączyć lub wyłączyć tryb wielu okien w przypadku interfejsu API na poziomie 30 i niższym, ustaw ten atrybut w elemencie <activity> lub <application> w pliku manifestu:

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

Jeśli ten atrybut ma wartość true, aktywność można uruchomić w trybie podzielonego ekranu i w trybie okien na komputerze. Jeśli atrybut ma wartość false, aktywność nie obsługuje trybu wielu okien. Jeśli wartość to „false” i użytkownik spróbuje uruchomić aktywność w trybie wielu okien, aktywność zajmie cały ekran.

Jeśli Twoja aplikacja jest kierowana na interfejs API na poziomie 24 lub wyższym, ale nie określisz wartości tego atrybutu, domyślnie będzie on miał wartość „true”.

Jeśli Twoja aplikacja jest kierowana na interfejs API na poziomie 31 lub wyższym, ten atrybut działa inaczej na małych i dużych ekranach:

  • Duże ekrany (średnia lub rozszerzona klasa rozmiaru okna): wszystkie aplikacje obsługują tryb wielu okien. Atrybut wskazuje, czy aktywność może zmieniać rozmiar. Jeśli resizeableActivity="false", aplikacja jest w razie potrzeby przełączana w tryb zgodności, aby dostosować się do wymiarów wyświetlacza.
  • Małe ekrany (kompaktowa klasa rozmiaru okna): jeśliresizeableActivity="true" minimalna szerokość i minimalna wysokość aktywności mieszczą się w wymaganiach dotyczących wielu okien, aktywność obsługuje tryb wielu okien. Jeśli resizeableActivity="false", aktywność nie obsługuje trybu wielu okien niezależnie od minimalnej szerokości i wysokości aktywności.

Jeśli Twoja aplikacja jest kierowana na interfejs API na poziomie 36 lub wyższym, ten atrybut jest ignorowany na wyświetlaczach o najmniejszej szerokości ≥ 600 dp. Aplikacja w pełni respektuje jednak wybór formatu obrazu przez użytkownika (patrz Zastąpienia ustawień aplikacji przez użytkownika).

Jeśli tworzysz grę, zapoznaj się z artykułem Orientacja aplikacji, format obrazu i możliwość zmiany rozmiaru, aby dowiedzieć się, jak wykluczyć grę ze zmian wprowadzonych w Androidzie 16 (API na poziomie 36).

supportsPictureInPicture

Ustaw ten atrybut w węźle <activity> pliku manifestu, aby wskazać, czy aktywność obsługuje tryb obrazu w obrazie.

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

configChanges

Aby samodzielnie obsługiwać zmiany konfiguracji wielu okien, np. gdy użytkownik zmieni rozmiar okna, dodaj atrybut android:configChanges do węzła <activity> w pliku manifestu aplikacji z co najmniej tymi wartościami:

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

Po dodaniu android:configChanges Twoja aktywność i fragmenty otrzymają wywołanie zwrotne do onConfigurationChanged() zamiast zostać zniszczone i ponownie utworzone. Następnie możesz ręcznie aktualizować widoki, ponownie wczytywać zasoby i wykonywać inne operacje.

<layout>

W Androidzie 7.0 (poziom interfejsu API 24) i nowszych element manifestu <layout> obsługuje kilka atrybutów, które wpływają na działanie aktywności w trybie wielu okien:

  • android:defaultHeight, android:defaultWidth: domyślna wysokość i szerokość aktywności po uruchomieniu w trybie okien na pulpicie.

  • android:gravity: początkowe umieszczenie aktywności po uruchomieniu w trybie okien na komputerze. Odpowiednie wartości znajdziesz w klasie Gravity.

  • android:minHeight, android:minWidth: minimalna wysokość i minimalna szerokość aktywności w trybie podzielonego ekranu i trybie okien na pulpicie. Jeśli użytkownik przesunie separator w trybie podzielonego ekranu, aby zmniejszyć aktywność poniżej określonego minimum, system przytnie ją do rozmiaru, o który prosi użytkownik.

Poniższy kod pokazuje, jak określić domyślny rozmiar i położenie aktywności oraz jej minimalny rozmiar, gdy jest ona wyświetlana w trybie okien na komputerze:

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

Tryb wielu okien w czasie działania

Od Androida 7.0 system oferuje funkcje obsługujące aplikacje, które mogą działać w trybie wielu okien.

Wyłączone funkcje w trybie wielu okien

W trybie wielu okien Android może wyłączyć lub zignorować funkcje, które nie mają zastosowania do aktywności udostępniającej ekran urządzenia innym aktywnościom lub aplikacjom.

Dodatkowo niektóre opcje dostosowywania interfejsu systemu są wyłączone. Na przykład aplikacje nie mogą ukrywać paska stanu, jeśli działają w trybie wielu okien (patrz Kontrolowanie widoczności interfejsu systemu).

System ignoruje zmiany atrybutu android:screenOrientation.

Zapytania i wywołania zwrotne w trybie wielu okien

Klasa Activity udostępnia te metody obsługi trybu wielu okien:

  • isInMultiWindowMode(): wskazuje, czy aktywność jest w trybie wielu okien.

  • isInPictureInPictureMode(): wskazuje, czy aktywność jest w trybie obrazu w obrazie.

  • onMultiWindowModeChanged(): system wywołuje tę metodę, gdy aktywność wchodzi w tryb wielu okien lub z niego wychodzi. System przekazuje do metody wartość „true”, jeśli aktywność wchodzi w tryb wielu okien, lub „false”, jeśli z niego wychodzi.

  • onPictureInPictureModeChanged(): system wywołuje tę metodę za każdym razem, gdy aktywność przechodzi w tryb obrazu w obrazie lub z niego wychodzi. System przekazuje do metody wartość „true”, jeśli aktywność przechodzi w tryb obrazu w obrazie, lub „false”, jeśli z niego wychodzi.

Klasa Fragment udostępnia wersje wielu z tych metod, np. Fragment.onMultiWindowModeChanged().

Tryb obrazu w obrazie

Aby włączyć tryb obrazu w obrazie, wywołaj metodę enterPictureInPictureMode(). Jeśli urządzenie nie obsługuje trybu obrazu w obrazie, ta metoda nie ma żadnego efektu. Więcej informacji znajdziesz w artykule Dodawanie filmów w trybie obraz w obrazie.

Nowe aktywności w trybie wielu okien

Gdy uruchamiasz nową aktywność, możesz wskazać, że powinna ona być wyświetlana obok bieżącej aktywności, jeśli to możliwe. Użyj flagi intencji FLAG_ACTIVITY_LAUNCH_ADJACENT, która informuje system, że ma spróbować utworzyć nową aktywność w sąsiednim oknie, aby obie aktywności były wyświetlane na ekranie obok siebie. System dokłada wszelkich starań, aby to zrobić, ale nie jest to gwarantowane.

Jeśli urządzenie jest w trybie okien na komputerze i uruchamiasz nową aktywność, możesz określić jej wymiary i położenie na ekranie, wywołując metodę ActivityOptions.setLaunchBounds(). Metoda nie działa, jeśli urządzenie nie jest w trybie wielu okien.

W interfejsie API w wersji 30 i starszych, jeśli uruchomisz działanie w stosie zadań, zastąpi ono działanie na ekranie, dziedzicząc wszystkie jego właściwości związane z wieloma oknami. Jeśli chcesz uruchomić nową aktywność jako osobne okno w trybie wielu okien, musisz uruchomić ją w nowym stosie zadań.

Android 12 (poziom API 31) umożliwia aplikacjom dzielenie okna zadania aplikacji na kilka działań. Sposób wyświetlania aktywności aplikacji – na pełnym ekranie, obok siebie lub w stosie – określasz, tworząc plik konfiguracyjny XML lub wywołując interfejs Jetpack WindowManager API.

Przeciąganie i upuszczanie

Użytkownicy mogą przeciągać dane z jednej aktywności do drugiej, gdy obie aktywności są wyświetlane na ekranie. (Przed Androidem 7.0 użytkownicy mogli przeciągać i upuszczać dane tylko w ramach jednej aktywności). Aby szybko dodać obsługę akceptowania upuszczonych treści, zapoznaj się z interfejsem DropHelper API. Szczegółowe informacje o przeciąganiu i upuszczaniu znajdziesz w artykule Włączanie przeciągania i upuszczania.

Wiele instancji

Każda aktywność główna ma własne zadanie, które jest wyświetlane w osobnym oknie. Aby uruchomić nową instancję aplikacji w osobnym oknie, rozpocznij nowe działania z użyciem flagi FLAG_ACTIVITY_NEW_TASK. To ustawienie możesz połączyć z atrybutami wielu okien, aby poprosić o określoną lokalizację nowego okna. Na przykład aplikacja zakupowa może wyświetlać kilka sąsiadujących okien, aby porównać produkty.

Android 12 (API na poziomie 31) i nowsze wersje umożliwiają uruchamianie 2 wystąpień aktywności obok siebie w tym samym oknie zadania w ramach osadzania aktywności.

Jeśli chcesz zezwolić użytkownikom na uruchamianie kolejnej instancji aplikacji z poziomu launchera lub paska zadań, ustaw android:resizeableActivity="true" w pliku manifestu aktywności launchera i nie używaj trybu uruchamiania, który uniemożliwia uruchamianie wielu instancji. Na przykład singleInstancePerTask działanie może być wielokrotnie tworzone w różnych zadaniach, gdy ustawiona jest opcja FLAG_ACTIVITY_MULTIPLE_TASK lub FLAG_ACTIVITY_NEW_DOCUMENT.

Na Androidzie 15 (API na poziomie 35) i nowszym element PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI umożliwia deklarowanie obsługi wielu instancji. Właściwość jest wyraźnym sygnałem dla interfejsu systemu, aby udostępniać użytkownikowi elementy sterujące umożliwiające tworzenie wielu instancji aplikacji. Właściwość jest niezależna od trybu uruchamiania, ale powinna być używana tylko wtedy, gdy tryb uruchamiania aktywności lub aplikacji jest z nią zgodny, np. gdy tryb uruchamiania nie jest singleInstance.

Gdy na urządzeniu składanym w osobnych oknach działa kilka instancji aplikacji, jedna lub więcej z nich może zostać przeniesiona w tle, jeśli zmieni się położenie urządzenia. Załóżmy na przykład, że urządzenie jest rozłożone i ma 2 instancje aplikacji działające w osobnych oknach po obu stronach zagięcia. Jeśli urządzenie jest złożone, jeden z tych przypadków może zostać zamknięty zamiast próby dopasowania okien obu przypadków do mniejszego ekranu.

Weryfikacja trybu wielu okien

Niezależnie od tego, czy Twoja aplikacja jest kierowana na interfejs API na poziomie 24 lub wyższym, sprawdź, jak działa w trybie wielu okien, na wypadek gdyby użytkownik spróbował uruchomić ją w tym trybie na urządzeniu z Androidem 7.0 lub nowszym.

Urządzenia testowe

Urządzenia z Androidem 7.0 (interfejs API na poziomie 24) lub nowszym obsługują tryb wielu okien.

poziom API 23 lub niższy.

Gdy użytkownicy spróbują użyć aplikacji w trybie wielu okien, system wymusi zmianę rozmiaru aplikacji, chyba że zadeklaruje ona stałą orientację.

Jeśli aplikacja nie deklaruje stałej orientacji, uruchom ją na urządzeniu z Androidem 7.0 lub nowszym i spróbuj włączyć tryb podzielonego ekranu. Sprawdź, czy aplikacja działa prawidłowo po wymuszonej zmianie rozmiaru.

Jeśli aplikacja deklaruje stałą orientację, spróbuj uruchomić ją w trybie wielu okien. Sprawdź, czy po wykonaniu tej czynności aplikacja pozostaje w trybie pełnoekranowym.

Poziomy interfejsu API od 24 do 30

Jeśli Twoja aplikacja jest kierowana na poziomy interfejsu API od 24 do 30 i nie wyłącza obsługi wielu okien, sprawdź, czy w trybach dzielenia ekranu i okien na komputerze działa w ten sposób:

  • Uruchom aplikację w trybie pełnoekranowym, a następnie przełącz się na tryb wielu okien, przytrzymując przycisk Ostatnie. Sprawdź, czy aplikacja przełącza się prawidłowo.

  • Uruchom aplikację bezpośrednio w trybie wielu okien i sprawdź, czy działa prawidłowo. Aby uruchomić aplikację w trybie wielu okien, naciśnij przycisk Ostatnie, a następnie przytrzymaj pasek tytułu aplikacji i przeciągnij go do jednego z wyróżnionych obszarów na ekranie.

  • Zmień rozmiar aplikacji w trybie podzielonego ekranu, przeciągając linię podziału. Sprawdź, czy aplikacja zmienia rozmiar bez awarii i czy widoczne są niezbędne elementy interfejsu.

  • Jeśli masz określone minimalne wymiary aplikacji, spróbuj zmienić jej rozmiar tak, aby rozmiar okna był mniejszy niż te wymiary. Sprawdź, czy nie możesz zmniejszyć aplikacji poniżej określonych minimalnych wymiarów.

  • Podczas wszystkich testów sprawdzaj, czy wydajność aplikacji jest zadowalająca. Na przykład sprawdź, czy po zmianie rozmiaru aplikacji nie występuje zbyt duże opóźnienie w aktualizacji interfejsu.

poziom API 31 lub wyższy.

Jeśli aplikacja jest kierowana na interfejs API na poziomie 31 lub wyższym, a minimalna szerokość i minimalna wysokość głównej aktywności są mniejsze lub równe odpowiednim wymiarom dostępnego obszaru wyświetlania, sprawdź wszystkie zachowania wymienione w sekcji Poziomy interfejsu API od 24 do 30.

Lista kontrolna testów

Aby sprawdzić działanie aplikacji w trybie wielu okien, wykonaj te czynności: Wypróbuj te działania w trybie podzielonego ekranu i w trybie okien na komputerze, chyba że podano inaczej.

  • Włączanie i wyłączanie trybu wielu okien.

  • Przełącz się z aplikacji na inną i sprawdź, czy działa ona prawidłowo, gdy jest widoczna, ale nieaktywna. Jeśli na przykład aplikacja odtwarza film, sprawdź, czy odtwarzanie jest kontynuowane, gdy użytkownik korzysta z innej aplikacji.

  • W trybie podzielonego ekranu spróbuj przesunąć linię podziału, aby powiększyć i pomniejszyć aplikację. Wypróbuj te operacje w konfiguracjach obok siebie i jedna nad drugą. Sprawdź, czy aplikacja nie ulega awarii, czy widoczne są podstawowe funkcje i czy zmiana rozmiaru nie trwa zbyt długo.

  • Wykonaj kilka operacji zmiany rozmiaru w szybkiej kolejności. Sprawdź, czy aplikacja nie ulega awarii ani nie powoduje wycieku pamięci. Narzędzie Memory Profiler w Android Studio dostarcza informacji o użyciu pamięci przez aplikację (więcej informacji znajdziesz w artykule Sprawdzanie użycia pamięci przez aplikację za pomocą narzędzia Memory Profiler).

  • Używaj aplikacji w różnych konfiguracjach okien i sprawdź, czy działa prawidłowo. Sprawdź, czy tekst jest czytelny, a elementy interfejsu nie są zbyt małe, aby można było z nich korzystać.

Obsługa wielu okien wyłączona

Jeśli na poziomach API od 24 do 30 wyłączysz obsługę wielu okien, ustawiając android:resizeableActivity="false", uruchom aplikację na urządzeniu z Androidem w wersji od 7.0 do 11 i spróbuj włączyć tryb podzielonego ekranu oraz tryb okien na komputerze. Sprawdź, czy po wykonaniu tej czynności aplikacja pozostaje w trybie pełnoekranowym.

Dodatkowe materiały

Więcej informacji o obsłudze wielu okien na Androidzie znajdziesz w tych artykułach:

Wstecz
Używanie klas rozmiarów okien
Dalej
Obsługa okna pulpitu