Obsługa trybu wielu okien

Tryb wielu okien umożliwia jednoczesne korzystanie z tego samego ekranu wielu aplikacjom. Aplikacje mogą znajdować się obok siebie lub jedna nad drugą (w trybie podzielonego ekranu), jedna w małe okno nakładające się na inne aplikacje (tryb obrazu w obrazie) lub pojedyncze w osobnych oknach z możliwością zmiany rozmiaru.

Wygoda użytkowników zależy od wersji Androida i typu urządzenia:

• W Androidzie 7.0 (poziom interfejsu API 24) wprowadzono tryb podzielonego ekranu na małym ekranie i tryb obrazu w obrazie na wybranych urządzeniach.

  • Tryb podzielonego ekranu wypełnia ekran dwoma aplikacjami, pokazując je obok siebie lub jeden nad drugim. Użytkownicy mogą przeciągać separator rozdzielając je w taki sposób, by jedna z nich była większa, a druga mniejsza.

  • Tryb obrazu w obrazie umożliwia użytkownikom kontynuowanie odtwarzania filmu. podczas interakcji z inną aplikacją (patrz Obsługa funkcji obraz w obrazie).

  • Tryb swobodny, w którym użytkownicy mogą dowolnie zmieniać rozmiar każdej aktywności, produkowane przez producentów urządzeń z dużym ekranem.

    Aby skonfigurować sposób obsługi trybu wielu okien w aplikacji, określ jej minimalne dopuszczalne wymiary. Możesz też wyłączyć trybu wielu okien w aplikacji, ustawiając resizeabableActivity="false", aby system zawsze się wyświetlał pełnego ekranu aplikacji.

• Android 8.0 (poziom interfejsu API 26) rozszerza tryb obrazu w obrazie na mały urządzenia ekranów.

• Android 12 (poziom interfejsu API 31) zapewnia standardowe działanie trybu wielu okien.

  • Na dużych ekranach (w klasie średniej lub rozszerzonej) wymiar platforma obsługuje wszystkie aplikacje w trybie wielu okien niezależnie od konfiguracji. Jeśli zasada resizeableActivity="false", aplikacja jest umieszczana w trybu zgodności, gdy jest to konieczne ze względu na wymiary wyświetlania.

  • Na małych ekranach (klasa rozmiaru okna kompaktowego) system sprawdza, minWidth i minHeight aktywności, które pozwalają ustalić, czy aktywność może działać w trybie wielu okien. Jeśli resizeableActivity="false", aplikacja nie może działać w trybu wielu okien niezależnie od minimalnej szerokości i wysokości.

  .

Tryb podzielonego ekranu

Aby włączyć tryb podzielonego ekranu, wykonaj te czynności:

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

Użytkownicy mogą wyłączyć tryb podzielonego ekranu, przeciągając separator okna do krawędzi w górę lub w dół, w lewo lub w prawo.

Uruchom obok

Jeśli aplikacja potrzebuje dostępu do treści za pośrednictwem intencji, możesz użyć FLAG_ACTIVITY_LAUNCH_ADJACENT, aby otworzyć zawartość w sąsiednim okno podzielonego ekranu.

FLAG_ACTIVITY_LAUNCH_ADJACENT został wprowadzony w Androidzie 7.0 (poziom interfejsu API 24) na: włącz aplikacje działające w trybie podzielonego ekranu, aby uruchamiać działania w sąsiednim okno.

W Androidzie 12L (poziom API 32) i nowszym definicja flagi została rozszerzona na włącz tryb podzielonego ekranu na aplikacje działające na pełnym ekranie, a następnie uruchom w sąsiednim oknie.

Aby uruchomić sąsiednią aktywność, użyj polecenia FLAG_ACTIVITY_LAUNCH_ADJACENT w spójnik 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) } }

public void openUrlInAdjacentWindow(String url) {
  Intent intent = new Intent(Intent.ACTION_VIEW);
  intent.setData(Uri.parse(url));
  intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT | Intent.FLAG_ACTIVITY_NEW_TASK);
  startActivity(intent);
}

Cykl 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 na urządzeniu z Androidem.

Wielokrotne wznowienie

Android 10 (poziom interfejsu API 29) i nowsze wersje obsługują wielokrotne wznawianie aktywności pozostają w stanie RESUMED, gdy urządzenie jest w trybie wielu okien i trybu uzyskiwania zgody. Działanie można wstrzymać, jeśli na pasku aktywności znajduje się przezroczysta aktywność działania lub czynności nie można zaznaczyć, na przykład ma ona miejsce trybie obraz w obrazie. Możliwe jest również, że żadna aktywność nie skupia się w określonym czasie, np. gdy szuflada powiadomień jest otwarta. onStop() działa jak zwykle: metoda jest wywoływana przy każdym przerwaniu działania na ekranie.

Wielokrotne wznawianie jest też dostępne na wybranych urządzeniach z Androidem 9 (poziom interfejsu API) 28). Aby włączyć wielokrotne wznawianie na urządzeniach z Androidem 9, dodaj ten plik manifestu metadane:

<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ę z specyfikację urządzenia.

Android 9

W trybie wielu okien na Androidzie 9 (poziom interfejsu API 28) lub starszym tylko aktywność użytkownik, z którym użytkownik ostatnio korzystał, jest aktywny w danym momencie. Ten aktywność jest uważana za najwyższą i jest jedyną aktywnością w RESUMED state. Wszystkie inne widoczne aktywności są STARTED, ale nie RESUMED. System nadaje jednak wyższą widoczność tym aktywnościom, które nie zostały wznowione, mają wyższy priorytet niż działania, które nie są widoczne. Jeśli użytkownik wejdzie w interakcję z jedną z tych widoczna aktywność, wznowiona aktywność aktywność przechodzi w stan STARTED.

Jeśli w jednym aktywnym procesie aplikacji jest wiele działań, aktywność o najwyższej kolejności na osi Z zostanie wznowiona, a pozostałe – wstrzymane.

Zmiany konfiguracji

Gdy użytkownik włączy aplikację w tryb wielu okien, system powiadomi aktywność związaną ze zmianą konfiguracji, zgodnie z opisem w sekcji Obsługa konfiguracji zmian. Dzieje się tak również wtedy, gdy użytkownik zmienia rozmiar aplikacji lub umieszcza ją z powrotem. w trybie pełnego ekranu.

Zasadniczo ta zmiana ma takie same konsekwencje dla cyklu życia aktywności system powiadomi aplikację, że urządzenie przełączyło się z orientacji pionowej na w orientacji poziomej, z tą różnicą, że wymiary aplikacji są zmieniane, a nie tylko zamianę. Twoja aktywność może samodzielnie zmieniać konfigurację lub aplikacja może umożliwić systemowi zniszczenie aktywności i odtworzenie jej za pomocą nowych wymiarów.

Jeśli użytkownik zmieni rozmiar okna i zwiększy je w obu wymiarach, system zmienia rozmiar aktywności, aby dopasować ją do działania użytkownika i konfiguracji problemów w razie potrzeby. Jeśli aplikacja ma opóźnienia w rysowaniu w nowych obszarach, tymczasowo wypełnia te obszary kolorem określonym przez windowBackground lub domyślnie windowBackgroundFallback.

Wyłączny dostęp do zasobów

Aby ułatwić sobie obsługę funkcji wielokrotnego wznawiania, skorzystaj z onTopResumedActivityChanged() Wywołanie zwrotne cyklu życia.

Wywołanie zwrotne jest wywoływane, gdy aktywność zyskuje lub traci najczęściej wznowioną aktywność pozycji, co jest ważne, gdy aktywność wykorzystuje wspólny zasób typu singleton, takich 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. } }

@Override
public void onTopResumedActivityChanged(boolean topResumed) {
  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, takich jak usunięcie To wspólny sprzęt.

W każdym przypadku aplikacja powinna bezproblemowo obsługiwać zdarzenia i wprowadzać zmiany, co wpływa na dostępne zasoby.

W przypadku aplikacji korzystających z aparatu CameraManager.AvailabilityCallback#onCameraAccessPrioritiesChanged() podpowiada, że może być dobry moment, by spróbować uzyskać dostęp do aparatu. Ta metoda jest dostępna w Androidzie 10 (poziom API 29).

Pamiętaj, że resizeableActivity=false nie gwarantuje wyjątkowego aparatu fotograficznego ponieważ aplikacje korzystające z aparatu można otwierać na innych ekranach.

Aplikacja nie musi zwalniać aparatu, gdy traci ostrość. Możesz na przykład wyświetlać podgląd z aparatu, gdy użytkownik wchodzi w interakcję z nowo zaznaczoną aplikacją, która jest najczęściej wznowiona. Aplikacja może zachować Uruchomienie kamery, gdy nie jest to najczęściej wznowiona aplikacja, ale musi do etui, aby je odłączyć. Gdy najczęściej wznowiona aplikacja chce używać polecenia aparatu, może go otworzyć, a aplikacja utraci dostęp. Aplikacja może ponownie otworzyć aparat, gdy aplikacja ponownie ustawi ostrość.

Gdy aplikacja otrzyma CameraDevice.StateCallback#onDisconnected() wywołanie zwrotne, kolejne połączenia z aparatu będą powodowały CameraAccessException.

Wieloekranowe

Android 10 (poziom interfejsu API 29) obsługuje działania na ekranach dodatkowych. Jeśli aktywność jest uruchomiona na urządzeniu z wieloma wyświetlaczami, użytkownicy mogą przenieść z jednego ekranu na drugi. Wielokrotne wznowienie obowiązuje w przypadku: optymalizacji pod kątem wielu urządzeń, niektóre działania mogą otrzymywać dane wejściowe użytkownika na jednocześnie.

Aplikacja może określić, na jakim wyświetlaczu powinna się wyświetlać w momencie uruchomienia lub kiedy tworzy kolejną aktywność. To zachowanie zależy od trybu uruchamiania aktywności zdefiniowane w pliku manifestu oraz flagach i opcjach intencji ustawionych przez podmiot uruchamiający aktywność. Więcej informacji znajdziesz w zajęciach ActivityOptions .

Gdy działanie przenosi się na wyświetlacz dodatkowy, może przejść przez kontekst aktualizacji, zmiany rozmiaru okien oraz konfiguracji i zasobów. Jeśli aktywność przetworzy zmianę konfiguracji, aktywność zostanie powiadomiona w onConfigurationChanged() W przeciwnym razie aktywność zostanie wznowiona.

Działanie powinno sprawdzać bieżący wyświetlacz w obszarach onCreate() oraz onConfigurationChanged() w przypadku zmiany konfiguracji. Upewnij się, że: aktualizować zasoby i układy po zmianie widoku.

Jeśli wybrany tryb uruchamiania działania pozwala na więcej instancji, uruchomienie na dodatkowym ekranie może utworzyć nowe wystąpienie działania. Obie aktywności są wznawiane w tym samym czasie.

Możesz też poczytać o interfejsach API multi-displayowych wprowadzonych w Androidzie 8.0.

Kontekst działania lub aplikacji

W przypadku wielu wyświetlaczy kluczowe znaczenie ma użycie odpowiedniego kontekstu. Podczas uzyskiwania dostępu do zasobów kontekst działania (który jest wyświetlany) różni się od kontekstu aplikacji kontekst (który nie jest).

Kontekst aktywności zawiera informacje o wyświetlaczu i jest zawsze dostosowane do obszaru wyświetlania, w którym pojawia się aktywność. Dzięki temu możesz: podaj prawidłowe dane o gęstości wyświetlania lub oknach . Należy zawsze korzystać z kontekstu działania (lub innego interfejsu opartego na interfejsie) kontekst), aby uzyskać informacje o bieżącym oknie lub wyświetlaczu. To także wpływa na niektóre systemowe interfejsy API, które wykorzystują informacje z kontekstu (na przykład zobacz Komunikaty ogólne).

Konfiguracja okna aktywności oraz wyświetlacz nadrzędny definiują zasoby i dodaje kontekst. Pobierz bieżący obraz w ten sposób:

val activityDisplay = activity.getDisplay()

Display activityDisplay = activity.getDisplay();

Pobierz dane dotyczące bieżącego okresu aktywności:

val windowMetrics = activity.getWindowManager().getCurrentWindowMetrics()

WindowMetrics windowMetrics = activity.getWindowManager().getCurrentWindowMetrics();

Pobierz maksymalne wskaźniki okien dla bieżącej konfiguracji systemu:

val maximumWindowMetrics = activity.getWindowManager().getMaximumWindowMetrics()

WindowMetrics maximumWindowMetrics = activity.getWindowManager().getMaximumWindowMetrics();

Maksymalne dane dotyczące okien służą do dokonywania obliczeń, wyboru układu lub określające zasoby do pobrania z wyprzedzeniem. Dostęp do tych informacji w onCreate() umożliwia Ci podjęcie tych decyzji przed pierwszym układem pomyślne. Tych danych nie należy używać do określania określonych elementów widoku danych. zamiast tego użyj informacji z obiektu Configuration.

Wycięcia w ekranie

Urządzenia składane mogą mieć inną geometrię wycięcia po złożeniu i rozłożeniu. Aby uniknąć problemów z wycięciem, zapoznaj się z sekcją Obsługa wycięć w ekranie.

Wyświetlacze dodatkowe

Listę dostępnych ekranów możesz pobrać z usługi systemowej DisplayManager:

val displayManager =
getSystemService(Context.DISPLAY_SERVICE) as DisplayManager val displays =
displayManager.getDisplays()

DisplayManager displayManager = (DisplayManager) getSystemService(Context.DISPLAY_SERVICE);
Display[] displays = displayManager.getDisplays();

Użyj klasy Display, aby uzyskać informacje o konkretnym wyświetlaczu, na przykład jak rozmiar wyświetlacza lub flagi wskazujące, czy wyświetlacz jest bezpieczny. Nie zakładaj jednak, że rozmiar wyświetlacza będzie taki sam jak obszar wyświetlania przypisany do Twojej aplikacji. Pamiętaj, że w trybie wielu okien aplikacja zajmuje część ekranu.

Określ, czy działanie może być uruchamiane na wyświetlaczu:

val activityManager =
getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager val
activityAllowed = activityManager.isActivityStartAllowedOnDisplay(context,
displayId, intent)

ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
boolean activityAllowed = activityManager.isActivityStartAllowedOnDisplay(context, displayId, intent);

Następnie uruchom aktywność na wyświetlaczu:

val options = ActivityOptions.makeBasic()
options.setLaunchDisplayId(targetDisplay.displayId) startActivity(intent,
options.toBundle())

ActivityOptions options = ActivityOptions.makeBasic();
options.setLaunchDisplayId(targetDisplay.displayId);
startActivity(intent, options.toBundle());

Obsługa kilku wyświetlaczy

Android zapewnia obsługę wielu wyświetlaczy, np. klawiatur programowych, tapet program uruchamiający.

Klawiatura programowa

Na ekranie dodatkowym może być wyświetlana klawiatura, jeśli wyświetlacz jest skonfigurowany dekoracje systemu pomocy. Edytor metody wprowadzania pojawia się automatycznie, jeśli wymaga wprowadzenia danych przez pole tekstowe.

Tapeta

W Androidzie 10 (poziom interfejsu API 29) ekrany dodatkowe mogą mieć tapetę. platforma tworzy osobną instancję WallpaperService.Engine dla każdej wyświetlacz. Powierzchnię każdego silnika rysuj niezależnie. Programiści mogą wczytywać zasoby, używając kontekstu wyświetlania w WallpaperService.Engine#getDisplayContext(). Upewnij się również, że atrybuty Plik WallpaperInfo.xml ustawia android:supportsMultipleDisplays="true".

Launchery

Nowa kategoria filtra intencji, SECONDARY_HOME, zapewnia dedykowane działanie na ekranach dodatkowych. Wystąpienia aktywności są używane na wszystkich wyświetlaczach, które dekoracji systemu, po jednej na każdy wyświetlacz.

<activity>
    ...
    <intent-filter>
        <category android:name="android.intent.category.SECONDARY_HOME" />
        ...
    </intent-filter>
</activity>

Działanie musi mieć tryb uruchamiania, który nie blokuje wielu instancji które dostosowują się do różnych rozmiarów ekranu. Tryb uruchamiania nie może być singleInstance lub singleTask.

Na przykład implementacja AOSP Launcher3 obsługuje SECONDARY_HOME – aktywność.

.

Dane dotyczące okien

W Androidzie 11 (poziom interfejsu API 30) wprowadziliśmy te metody WindowManager aby określić granice aplikacji działających w trybie wielu okien:

• getCurrentWindowMetrics(): zwraca obiekt WindowMetrics dla bieżącego stanu okien systemu.
• getMaximumWindowMetrics(): zwraca WindowMetrics dla największej wartości potencjalnego stanu okna systemu.

Metody biblioteki Jetpack WindowManager computeCurrentWindowMetrics() i computeMaximumWindowMetrics() oferują podobne funkcje , ale zapewnia zgodność wsteczną z interfejsem API poziomu 14.

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

• Tworzenie kontekstu wyświetlania
• Utwórz kontekst okna dla wyświetlacza
• Pobieranie WindowManager kontekstu okna
• Wykorzystaj 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

WindowMetrics windowMetrics = context.createDisplayContext(display)
                            .createWindowContext(WindowManager.LayoutParams.TYPE_APPLICATION, null)
                            .getSystemService(WindowManager.class)
                            .getMaximumWindowMetrics();

Wycofane metody

Metody getSize() i getMetrics() (Display) zostały wycofane w Poziom interfejsu API 30 na korzyść nowych metod WindowManager.

Android 12 (poziom interfejsu API 31) wycofuje metody Display getRealSize() i getRealMetrics() i aktualizuje ich działanie, aby lepiej dopasować działanie witryny getMaximumWindowMetrics().

Konfiguracja trybu wielu okien

Jeśli Twoja aplikacja jest kierowana na Androida 7.0 (poziom interfejsu API 24) lub nowszego, możesz skonfigurować sposób oraz czy aktywność w aplikacji obsługuje tryb wielu okien. Możesz ustawić w pliku manifestu, aby kontrolować zarówno rozmiar, jak i układ. Aktywność główna ustawienia atrybutów mają zastosowanie do wszystkich działań w jej stosie zadań. Przykład: jeśli główna aktywność ma android:resizeableActivity="true", to wszystko aktywności w stosie zadań można zmieniać. Na niektórych większych urządzeniach, takich jak na Chromebookach, aplikacja może działać w oknie z możliwością zmiany rozmiaru, nawet jeśli określisz android:resizeableActivity="false" Jeśli spowoduje to przerwanie działania aplikacji, możesz: filtry w Google Play, by ograniczyć dostępność aplikacji na takich urządzeniach.

Android 12 (poziom interfejsu API 31) domyślnie używa trybu wielu okien. Na dużych ekranach (klasa rozmiaru okna średnia lub rozszerzona), wszystkie aplikacje działają w trybie wielu okien. niezależnie od konfiguracji aplikacji. Na małych ekranach system sprawdza minWidth, minHeight i resizeableActivity aktywności użytkowników i określ, czy aktywność może działać w trybie wielu okien.

resizeableActivity

Ustaw ten atrybut w <activity> lub <application> pliku manifestu element umożliwiający włączenie lub wyłączenie trybu wielu okien w interfejsie API na poziomie 30 lub niższym:

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

Jeśli ten atrybut ma wartość true, aktywność może być uruchamiana na podzielonym ekranie i trybach eksploracji swobodnej. Jeśli atrybut ma wartość false, aktywność nie obsługują tryb wielu okien. Jeśli wartość to false, a użytkownik próbuje po uruchomieniu w trybie wielu okien, ekranu.

Jeśli aplikacja jest kierowana na interfejs API na poziomie 24 lub wyższym, ale nie podasz wartości pola ten atrybut przyjmuje domyślną wartość „true”.

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

• Duże ekrany (klasa rozmiaru okna średni lub rozwinięty): wszystkie aplikacje. obsługują tryb wielu okien. Atrybut wskazuje, czy działanie może zmiany rozmiaru. Jeśli zasada resizeableActivity="false", aplikacja jest umieszczana w trybu zgodności, gdy jest to konieczne do dopasowania do wymiarów wyświetlania.
• Małe ekrany (klasa rozmiaru okna kompaktowego): jeśli resizeableActivity="true" i minimalna szerokość i minimalna szerokość aktywności spełnia wymagania trybu wielu okien, aktywność obsługuje tryb wielu okien. i trybu uzyskiwania zgody. Jeśli resizeableActivity="false", aktywność nie obsługuje danych w trybie wielu okien niezależnie od minimalnej szerokości i wysokości aktywności.

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 w konfiguracji wielu okien, na przykład gdy użytkownik zmienia rozmiar okna, dodaj do swojej aplikacji atrybut android:configChanges węzeł <activity> w pliku manifestu z co najmniej tymi wartościami:

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

Po dodaniu elementu android:configChanges Twoja aktywność i fragmenty otrzymają powiadomienie wywołanie zwrotne do onConfigurationChanged(), zamiast zostać zniszczone, na nowo. Możesz wtedy ręcznie aktualizować widoki, przeładować zasoby i wykonywać inne operacje w razie potrzeby.

<layout>

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

• android:defaultHeight, android:defaultWidth: domyślna wysokość i szerokość swoją aktywność w trybie swobodnym.

• android:gravity: początkowe miejsce docelowe aktywności po uruchomieniu w w trybie eksploracji swobodnej. Odpowiednie wartości znajdziesz w klasie Gravity.

• android:minHeight, android:minWidth: minimalna wysokość i minimalna szerokość do ćwiczeń zarówno na podzielonym ekranie, jak i w trybie swobodnym. Jeśli użytkownik się przeniesie w trybie podzielonego ekranu, aby aktywność była mniejsza niż określony minimum, system przycina aktywność do rozmiaru określonego dla użytkownika żądań.

Ten kod pokazuje, jak określić domyślny rozmiar i lokalizację aktywności i ich minimalnym rozmiarze, gdy aktywność jest wyświetlana w trybie eksploracji swobodnej:

<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

Począwszy od Androida 7.0 system oferuje funkcje obsługi aplikacji, 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, która udostępnia ekran urządzenia innym aktywnościom lub aplikacjom.

Dodatkowo niektóre opcje dostosowywania interfejsu systemowego są wyłączone. Przykład: aplikacje nie mogą ukrywać paska stanu, jeśli działają w trybie wielu okien (zobacz zarządzać widocznością interfejsu systemowego).

System ignoruje zmiany w atrybucie android:screenOrientation.

Zapytania i wywołania zwrotne w trybie wielu okien

Klasa Activity udostępnia poniższe metody obsługi trybu wielu okien. tryb:

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

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

• onMultiWindowModeChanged(): system wywołuje tę metodę za każdym razem, gdy przejście do trybu wielu okien lub z niego. System przekazuje metodę wartość „true”, jeśli aktywność przechodzi w tryb wielu okien, lub „fałsz”, jeśli aktywność przechodzi w tryb wielu okien; aktywność wychodzi z trybu wielu okien.

• onPictureInPictureModeChanged(): system wywołuje tę metodę za każdym razem, gdy aktywność przechodzi w tryb obrazu w obrazie lub z niego wychodzi. System spełnia wymagania metoda, jeśli aktywność wchodzi w tryb obraz w obrazie, lub false, jeśli aktywność wyłącza tryb obrazu w obrazie.

Klasa Fragment ujawnia wersje wielu z tych metod: np. Fragment.onMultiWindowModeChanged().

Tryb obrazu w obrazie

Aby włączyć tryb obrazu w obrazie, zadzwoń pod enterPictureInPictureMode() Ta metoda nie działa, jeśli urządzenie nie obsługują trybu obrazu w obrazie. Więcej informacji znajdziesz w artykule Dodawanie filmów za pomocą obraz w obrazie (PIP).

Nowe aktywności w trybie wielu okien

Gdy rozpoczynasz nowe działanie, możesz wskazać, że ma ono być wyświetlane obok bieżącego, jeśli to możliwe. Użyj flagi intencji FLAG_ACTIVITY_LAUNCH_ADJACENT, który informuje system, że ma spróbować utworzyć nową aktywność w sąsiednim oknie, więc będą one miały wspólny ekran. system stara się, aby tak się stało, ale nie jest to gwarantowane.

Jeśli urządzenie jest w trybie dowolnym i uruchamiasz nową aktywność, możesz określ wymiary i lokalizację ekranu nowej aktywności, wywołując ActivityOptions.setLaunchBounds(). Metoda nie działa, jeśli urządzenie nie jest w trybie wielu okien.

W przypadku interfejsu API na poziomie 30 lub niższym po uruchomieniu działania w stosie zadań funkcja aktywność zastępuje aktywność na ekranie, dziedzicząc całą aktywność trybu wielu okien. usług. Jeśli chcesz uruchomić nową aktywność jako osobne okno w trybie wielu okien, musisz uruchomić go w nowym stosie zadań.

Android 12 (poziom interfejsu API 31) umożliwia aplikacjom dzielenie okna zadań na wiele różnych sposobów. To Ty określasz, w jaki sposób aplikacja działań – na pełnym ekranie, obok siebie lub stos – przez utworzenie pliku XML, konfiguracji interfejsu Jetpack WindowManager API lub wykonywać wywołania interfejsu Jetpack WindowManager API.

Przeciągnij i upuść

Użytkownicy mogą przeciągać i upuszczać dane z jednej aktywności do drugiej, Aktywności udostępniają ekran. (Do Androida 7.0 użytkownicy mogli tylko przeciągać i upuść dane w ramach jednej aktywności). Aby szybko dodać obsługę akceptowania usunięte treści znajdują się w interfejsie API DropHelper. Kompletne przeciąganie i upuszczanie wskazówki znajdziesz w sekcji Włączanie przeciągania i upuszczania.

Wiele instancji

Każde działanie główne ma własne zadanie, które działa w osobnym procesie i jest wyświetli się w osobnym oknie. Aby uruchomić nowe wystąpienie aplikacji w osobnym możesz rozpocząć nowe działania, używając flagi FLAG_ACTIVITY_NEW_TASK. Ty można połączyć go z niektórymi atrybutami trybu wielu okien, aby zażądać konkretną lokalizację nowego okna. Na przykład w aplikacji zakupowej można wyświetlać w kilku oknach do porównywania produktów.

Android 12 (poziom interfejsu API 31) umożliwia uruchomienie 2 wystąpień aktywności obok siebie w tym samym oknie zadania.

Jeśli chcesz zezwolić użytkownikom na uruchamianie kolejnego wystąpienia Twojej aplikacji program uruchamiający lub pasek aplikacji, upewnij się, że aktywność ustawia android:resizeableActivity="true" i nie używa trybu uruchamiania, który zapobiega występowaniu wielu wystąpień. Na przykład aktywność w usłudze singleInstancePerTask może być inicjowana wiele razy w różnych zadaniach, Ustawiono FLAG_ACTIVITY_MULTIPLE_TASK lub FLAG_ACTIVITY_NEW_DOCUMENT.

Nie należy mylić wielu instancji z układem wielopanelowym, takim jak szczegóły listy prezentacji wykorzystującej interfejs SlidingPaneLayout, który działa wewnątrz jednego okno.

Pamiętaj, że gdy wiele instancji działa w osobnych oknach na urządzeniu składanym urządzenia, co najmniej 1 instancja może być wysyłana do tła, jeśli stan zmian. Załóżmy na przykład, że urządzenie jest rozłożone i ma 2 instancje aplikacji. działające w 2 oknach po obu stronach Jeśli urządzenie jest złożone, instancji mogą zostać przerwane, zamiast próbować dopasować okna na mniejszym ekranie.

Weryfikacja w trybie wielu okien

Sprawdź, czy aplikacja jest kierowana na interfejs API na poziomie 24 lub wyższym. działa w trybie wielu okien, gdy użytkownik próbuje otworzyć go w trybie wielu okien. na urządzeniu z Androidem 7.0 lub nowszym.

Urządzenia testowe

Urządzenia z Androidem 7.0 (poziom interfejsu API 24) lub nowszym obsługują tryb wielu okien.

Interfejs API na poziomie 23 lub niższym

Gdy użytkownik spróbuje użyć aplikacji w trybie wielu okien, system wymusza zmienia rozmiar aplikacji, chyba że aplikacja zadeklaruje stałą orientację.

Jeśli aplikacja nie deklaruje stałej orientacji, uruchom ją urządzenia z Androidem 7.0 lub nowszym i spróbować zainstalować aplikację. w trybie podzielonego ekranu. Upewnij się, że aplikacja jest akceptowalna dla użytkowników. których rozmiar został wymuszony.

Jeśli aplikacja deklaruje stałą orientację, spróbuj umieścić ją w tryb wielu okien. Upewnij się, że gdy to zrobisz, aplikacja pozostanie w trybie pełnoekranowym. i trybu uzyskiwania zgody.

Poziomy interfejsu API od 24 do 30

Jeśli Twoja aplikacja jest kierowana na interfejsy API na poziomach 24–30 i nie ma wyłączonego trybu wielu okien , sprawdź poniższe zachowanie przy podzielonym ekranie i przy swobodnym formacie tryby:

• Uruchom aplikację na pełnym ekranie, a potem przełącz się na tryb wielu okien przez wciskając i przytrzymując przycisk Ostatnie. Sprawdź, czy aplikacja przełącza się prawidłowo.

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

• Zmień rozmiar aplikacji w trybie podzielonego ekranu, przeciągając separator ekranu. Zweryfikuj aby rozmiar aplikacji nie ulegał awarii, a niezbędne elementy interfejsu widoczne.

• Jeśli zostały określone minimalne wymiary aplikacji, spróbuj zmienić rozmiar aplikacji, tak by okno było mniejsze od tych wymiarów. Sprawdź, czy nie możesz zmienić rozmiaru aplikacji tak, aby była mniejsza niż określona wartość minimalna wymiarów.

• Poprzez wszystkie testy sprawdź, czy wydajność aplikacji jest akceptowalna. Dla: sprawdź na przykład, czy nie występuje zbyt duże opóźnienie w aktualizacji interfejsu użytkownika po rozmiar aplikacji został zmieniony.

Interfejs API na poziomie 31 lub wyższym

Jeśli aplikacja jest kierowana na interfejs API na poziomie 31 lub wyższym i minimalną szerokość głównej aktywności a minimalna wysokość jest mniejsza od lub równa odpowiedniemu wymiarowi dostępnego obszaru wyświetlania, sprawdź wszystkie zachowania wymienione dla poziomów interfejsu API 24. do 30.

Lista kontrolna testów

Aby sprawdzić wydajność aplikacji w trybie wielu okien, wykonaj te czynności operacji. Wypróbuj te operacje zarówno na podzielonym ekranie, jak i na dowolnym ekranie. o ile nie zaznaczono inaczej.

• Włącz i wyjdź z trybu wielu okien.

• Przełącz się z aplikacji na inną i sprawdź, czy działa. gdy jest widoczny, ale nie aktywny. Jeśli na przykład Twoja aplikacja jest podczas odtwarzania filmu, sprawdź, czy film jest odtwarzany, gdy użytkownik interakcji z inną aplikacją.

• W trybie podzielonego ekranu spróbuj przesunąć separator ekranu, aby aplikacja była jednocześnie większy i mniejszy. Przetestuj te operacje obok siebie i jedną powyżej i pozostałych konfiguracji. Upewnij się, że aplikacja nie ulega awarii, istotne jest widoczna, a zmiana rozmiaru nie trwa zbyt długo.

• Wykonuj kilka operacji zmiany rozmiaru w krótkich odstępach czasu. Sprawdzanie, czy aplikacja nie ulega awarii ani nie wycieka pamięci. Narzędzie do profilowania pamięci w Android Studio zapewnia informacje o wykorzystaniu pamięci przez aplikację (patrz Sprawdzanie pamięci aplikacji za pomocą narzędzia Memory Profiler).

• używaj aplikacji w różnych konfiguracjach okien; sprawdzić, czy aplikacja działa prawidłowo. Sprawdź, czy tekst jest czytelny i Elementy interfejsu nie są zbyt małe, aby można było z nimi korzystać.

Obsługa wielu okien wyłączona

na poziomach interfejsu API od 24 do 30, jeśli obsługa wielu okien została wyłączona przez ustawienie android:resizeableActivity="false", należy uruchomić aplikację na urządzeniu z Androidem od 7.0 do 11, podzielić aplikację na podzielony ekran, w trybach eksploracji swobodnej. Upewnij się, że aplikacja działa wtedy w trybie pełnoekranowym. i trybu uzyskiwania zgody.

Dodatkowe materiały

Więcej informacji o obsłudze wielu okien na Androidzie znajdziesz tutaj:

• Przykład aplikacji MultiWindowPlayground na Androida