Supporto della modalità multi-finestra

La modalità a più finestre consente a più app di condividere contemporaneamente la stessa schermata. Le app possono essere una accanto all'altra o una sopra l'altra (modalità schermo diviso), un'app in una piccola finestra sovrapposta ad altre app (modalità Picture in picture) o singole app in finestre separate, ridimensionabili e spostabili (modalità finestra del computer).

Per le istruzioni per gli utenti su come accedere alla modalità schermo diviso sugli smartphone, consulta Visualizzare due app contemporaneamente sullo smartphone Pixel.

Funzionalità multi-finestra specifiche per versione

L'esperienza utente con più finestre dipende dalla versione di Android e dal tipo di dispositivo:

• Android 7.0 (livello API 24) ha introdotto la modalità schermo diviso sui dispositivi con schermo piccolo e la modalità Picture in Picture su alcuni dispositivi.

  • La modalità schermo diviso riempie lo schermo con due app, mostrandole affiancate o una sopra l'altra. Gli utenti possono trascinare la barra di separazione tra le due app per ingrandire una e rimpicciolire l'altra.

  • La modalità Picture in picture consente agli utenti di continuare la riproduzione dei video mentre interagiscono con un'altra app (vedi Supporto della modalità Picture in picture).

  • La modalità finestra del desktop, in cui gli utenti possono ridimensionare liberamente ogni attività, può essere attivata dai produttori di dispositivi con schermi di grandi dimensioni.

    Puoi configurare il modo in cui la tua app gestisce la modalità a più finestre specificando le dimensioni minime consentite della tua attività. Puoi anche disattivare la modalità a più finestre per la tua app impostando resizeableActivity="false" per assicurarti che il sistema mostri sempre la tua app a schermo intero.

• Android 8.0 (livello API 26) estende la modalità Picture in picture ai dispositivi con schermo di piccole dimensioni.

• In Android 12 (livello API 31) la modalità a più finestre è il comportamento standard.

  • Su schermi di grandi dimensioni (classe di dimensioni della finestra media o estesa), la piattaforma supporta tutte le app in modalità multifinestra, indipendentemente dalla configurazione dell'app. Se resizeableActivity="false", l'app viene messa in modalità di compatibilità quando necessario per adattarsi alle dimensioni del display.

  • Su schermi di piccole dimensioni (classe di dimensioni della finestra compatta), il sistema controlla minWidth e minHeight di un'attività per determinare se l'attività può essere eseguita in modalità multifinestra. Se resizeableActivity="false", all'app viene impedita l'esecuzione in modalità multifinestra, indipendentemente dalla larghezza e dall'altezza minime.

Modalità schermo diviso

Gli utenti attivano la modalità schermo diviso nel seguente modo:

1. Apri la schermata Recenti.
2. Scorri un'app in modo che sia visibile
3. Premi l'icona dell'app nella barra del titolo dell'app
4. Seleziona l'opzione di menu dello schermo diviso
5. Seleziona un'altra app dalla schermata Recenti o chiudi la schermata Recenti e avvia un'altra app

Gli utenti escono dalla modalità schermo diviso trascinando il divisore della finestra sul bordo dello schermo verso l'alto o verso il basso, verso sinistra o verso destra.

Avvia app adiacente

Se la tua app deve accedere ai contenuti tramite un'intent, puoi utilizzare FLAG_ACTIVITY_LAUNCH_ADJACENT per aprirli in una finestra con schermo diviso adiacente.

FLAG_ACTIVITY_LAUNCH_ADJACENT è stato introdotto in Android 7.0 (livello API 24) per consentire alle app in esecuzione in modalità schermo diviso di avviare attività nella finestra adiacente.

Android 12L (livello API 32) e versioni successive hanno esteso la definizione del flag per consentire alle app in esecuzione a schermo intero di attivare la modalità a schermo diviso e quindi avviare le attività nella finestra adiacente.

Per avviare un'attività adiacente, utilizza FLAG_ACTIVITY_LAUNCH_ADJACENT in combinazione con FLAG_ACTIVITY_NEW_TASK, ad esempio:

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

Ciclo di vita dell'attività in modalità multi-finestra

La modalità a più finestre non modifica il ciclo di vita dell'attività. Tuttavia, lo stato di ripresa delle app in più finestre è diverso nelle varie versioni di Android.

Riprendi da dove avevi interrotto

Android 10 (livello API 29) e le versioni successive supportano la ripresa multipla: tutte le attività rimangono nello stato RESUMED quando il dispositivo è in modalità multi-finestra. Un'attività può essere messa in pausa se sopra è presente un'attività trasparente o se non è possibile attivare il relativo stato attivo, ad esempio se è attiva la modalità Picture in picture. È anche possibile che nessuna attività sia attiva in un determinato momento, ad esempio se la barra delle notifiche è aperta. Il metodo onStop() funziona come al solito: viene chiamato ogni volta che un'attività viene rimossa dallo schermo.

La funzionalità di ripresa multipla è disponibile anche su alcuni dispositivi con Android 9 (livello API 28). Per attivare la ripresa multipla sui dispositivi Android 9, aggiungi i seguenti metadati del manifest:

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

Per verificare che un determinato dispositivo supporti questi metadati manifest, consulta le specifiche del dispositivo.

Android 9

In modalità multi-finestra su Android 9 (livello API 28) e versioni precedenti, in un determinato momento è attiva solo l'attività con cui l'utente ha interagito più di recente. Questa attività è considerata principale ed è l'unica attività nello stato RESUMED. Tutte le altre attività visibili sono STARTED, ma non RESUMED. Tuttavia, il sistema assegna a queste attività visibili, ma non riprese, una priorità superiore rispetto alle attività non visibili. Se l'utente interagisce con una delle attività visibili, questa viene ripresa e l'attività precedentemente in primo piano entra nello stato STARTED.

Quando sono presenti più attività all'interno di un singolo processo dell'app attivo, viene ripresa l'attività con l'ordine z più alto e le altre vengono messe in pausa.

Modifiche alla configurazione

Quando l'utente inserisce un'app in modalità multifinestra, il sistema notifica l'attività di una modifica della configurazione come specificato in Gestire le modifiche della configurazione. Questo accade anche quando l'utente ridimensiona l'app o la rimette in modalità a schermo intero.

In sostanza, questa modifica ha le stesse implicazioni sul ciclo di vita dell'attività di quando il sistema comunica all'app che il dispositivo è passato dall'orientamento verticale a quello orizzontale, tranne per il fatto che le dimensioni dell'app vengono modificate anziché essere semplicemente scambiate. L'attività può gestire la modifica della configurazione stessa o la tua app può consentire al sistema di distruggere l'attività e ricrearla con le nuove dimensioni.

Se l'utente ridimensiona una finestra e la rende più grande in una delle dimensioni, il sistema ridimensiona l'attività in base all'azione dell'utente e apporta le modifiche di configurazione necessarie. Se l'app non riesce a disegnare le aree appena esposte, il sistema le riempie temporaneamente con il colore specificato dall'attributo windowBackground o dall'attributo di stile predefinito windowBackgroundFallback.

Accesso esclusivo alle risorse

Per supportare la funzionalità di ripresa multipla, utilizza il callback del ciclo di vita onTopResumedActivityChanged().

Il callback viene invocato quando un'attività acquisisce o perde la posizione di attività ripresa più importante, il che è importante quando un'attività utilizza una risorsa singleton condivisa, come il microfono o la videocamera:

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

Tieni presente che un'app può perdere risorse per altri motivi, ad esempio la rimozione di un componente hardware condiviso.

In ogni caso, un'app deve gestire in modo corretto gli eventi e le modifiche dello stato che influiscono sulle risorse disponibili.

Per le app che utilizzano una fotocamera, CameraManager.AvailabilityCallback#onCameraAccessPrioritiesChanged() fornisce un suggerimento che potrebbe essere un buon momento per provare ad accedere alla fotocamera. Questo metodo è disponibile a partire da Android 10 (livello API 29).

Ricorda che resizeableActivity=false non garantisce l'accesso esclusivo alla fotocamera, poiché altre app che utilizzano la fotocamera possono essere aperte su altri display.

Non è necessario che l'app rilasci la fotocamera quando perde il fuoco. Ad esempio, potresti voler continuare l'anteprima della fotocamera mentre l'utente interagisce con l'app di primo piano appena ripresa. Non è un problema se la tua app continua a gestire la fotocamera quando non è l'app di primo piano ripresa, ma deve gestire correttamente la situazione di disconnessione. Quando l'app ripresa più in alto vuole utilizzare la fotocamera, può aprirla e la tua app perderà l'accesso. L'app può riaprire la fotocamera quando riprende il controllo.

Dopo che un'app riceve un callback CameraDevice.StateCallback#onDisconnected(), le chiamate successive sul dispositivo della videocamera genereranno un CameraAccessException.

Multi-display

Android 10 (livello API 29) supporta le attività sui display secondari. Se un'attività è in esecuzione su un dispositivo con più display, gli utenti possono spostarla da un display all'altro. La funzionalità Riprendi più volte si applica anche agli scenari su più schermi; diverse attività possono ricevere input utente contemporaneamente.

Un'app può specificare su quale display deve essere eseguita al momento del lancio o quando crea un'altra attività. Questo comportamento dipende dalla modalità di lancio dell'attività definita nel file manifest e dagli indicatori e dalle opzioni di intent impostati dall'entità che avvia l'attività. Per ulteriori dettagli, consulta la classe ActivityOptions.

Quando un'attività viene spostata in un display secondario, può essere sottoposto a un aggiornamento del contesto, al ridimensionamento della finestra e a modifiche di configurazione e risorse. Se l'attività gestisce la modifica della configurazione, viene inviata una notifica in onConfigurationChanged(); in caso contrario, l'attività viene riavviata.

Un'attività deve controllare la visualizzazione corrente in onCreate() e onConfigurationChanged() se gestisce la modifica della configurazione. Assicurati di aggiornare le risorse e i layout quando il display cambia.

Se la modalità di lancio selezionata per un'attività consente più istanze, l'avvio su una schermata secondaria può creare una nuova istanza dell'attività. Entrambe le attività vengono riprese contemporaneamente.

Ti consigliamo anche di leggere le API per più display introdotte in Android 8.0.

Contesto di attività e contesto dell'applicazione

L'utilizzo del contesto corretto è fondamentale in multi-display. Quando accedi alle risorse, il contesto dell'attività (che viene visualizzato) è diverso dal contesto dell'applicazione (che non viene visualizzato).

Il contesto dell'attività contiene informazioni sul display ed è sempre adattato all'area di visualizzazione in cui viene visualizzata l'attività. In questo modo, puoi ottenere le informazioni corrette sulla densità del display o sulle metriche della finestra della tua app. Devi sempre utilizzare il contesto dell'attività (o un altro contesto basato sull'interfaccia utente) per ottenere informazioni sulla finestra o sul display corrente. Ciò riguarda anche alcune API di sistema che utilizzano le informazioni del contesto (ad esempio, consulta la Panoramica dei popup).

La configurazione della finestra delle attività e la visualizzazione principale definiscono le risorse e il contesto. Visualizza il display corrente come segue:

val activityDisplay = activity.getDisplay()

Display activityDisplay = activity.getDisplay();

Visualizza le metriche della finestra di attività corrente:

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

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

Visualizza le metriche della finestra massima per la configurazione di sistema corrente:

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

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

Le metriche della finestra massima sono utili per eseguire calcoli, scegliere il layout o determinare in anticipo le dimensioni delle risorse da recuperare. Avere questa funzionalità disponibile in onCreate() ti consente di prendere queste decisioni prima del primo passaggio di layout. Queste metriche non devono essere utilizzate per la disposizione di elementi di visualizzazione specifici. Utilizza invece le informazioni dell'oggetto Configuration.

Ritagli del display

I dispositivi pieghevoli potrebbero avere una geometria del ritaglio diversa quando sono aperti e chiusi. Per evitare problemi di ritagli, consulta Supportare i ritagli del display.

Display secondari

Puoi ottenere i display disponibili dal servizio di sistema DisplayManager:

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

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

Utilizza la classe Display per ottenere informazioni su un determinato display, ad esempio le dimensioni o i flag che indicano se un display è sicuro. Tuttavia, non dare per scontato che le dimensioni del display siano uguali all'area di visualizzazione allocata alla tua applicazione. Ricorda che in modalità multi-finestra, la tua applicazione occupa una parte del display.

Determina se un'attività può essere avviata su un display:

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

Quindi avvia l'attività sul display:

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

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

Supporto di più display

Android offre il supporto multi-display per tastiere software, sfondi e avviatori.

Tastiera software

Una tastiera può essere visualizzata su una schermata secondaria se il display è configurato per supportare le decorazioni di sistema. L'editor del metodo di inserimento viene visualizzato automaticamente se un campo di testo richiede l'inserimento su quel display.

Sfondo

In Android 10 (livello API 29), le schermate secondarie possono avere uno sfondo. Il framework crea un'istanza separata di WallpaperService.Engine per ogni display. Assicurati che la superficie di ogni motore sia disegnata in modo indipendente. Gli sviluppatori possono caricare gli asset utilizzando il contesto di visualizzazione in WallpaperService.Engine#getDisplayContext(). Inoltre, assicurati che il WallpaperInfo.xml file imposti android:supportsMultipleDisplays="true".

Avvio app

Una nuova categoria di filtro per intent, SECONDARY_HOME, fornisce un'attività dedicata per le schermate secondarie. Le istanze dell'attività vengono utilizzate su tutti i display che supportano le decorazioni di sistema, una per ogni display.

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

L'attività deve avere una modalità di lancio che non impedisca l'esecuzione di più istanze e che possa adattarsi a schermi di dimensioni diverse. La modalità di lancio non può essere singleInstance o singleTask.

Ad esempio, l'implementazione AOSP di Launcher3 supporta un'attività SECONDARY_HOME.

Metriche finestra

Android 11 (livello API 30) ha introdotto i seguenti metodi WindowManager per fornire i limiti delle app in esecuzione in modalità multi-finestra:

• getCurrentWindowMetrics(): restituisce un oggetto WindowMetrics per lo stato attuale della finestra del sistema.
• getMaximumWindowMetrics(): restituisce WindowMetrics per lo stato di finestre più grande possibile del sistema.

I metodi della libreria WindowManager di Jetpack computeCurrentWindowMetrics() e computeMaximumWindowMetrics() offrono funzionalità simili, rispettivamente, ma con compatibilità con le versioni precedenti al livello API 14.

Per ottenere le metriche per i display diversi da quello corrente, procedi come segue (come mostrato nello snippet di codice):

• Creare un contesto di visualizzazione
• Creare un contesto finestra per la visualizzazione
• Recupera il WindowManager del contesto della finestra
• Ottieni il WindowMetrics dell'area di visualizzazione massima disponibile per l'app

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();

Metodi ritirati

I metodi Display getSize() e getMetrics() sono stati ritirati nel livello API 30 a favore dei nuovi metodi WindowManager.

Android 12 (livello API 31) ritira i metodi Display getRealSize() e getRealMetrics() e aggiorna il loro comportamento in modo che sia più simile al comportamento di getMaximumWindowMetrics().

Configurazione della modalità multi-finestra

Se la tua app ha come target Android 7.0 (livello API 24) o versioni successive, puoi configurare la modalità multi-finestra e stabilire se le attività della tua app la supportano. Puoi impostare gli attributi nel file manifest per controllare sia le dimensioni sia il layout. Le impostazioni degli attributi di un'attività principale si applicano a tutte le attività all'interno del relativo stack di attività. Ad esempio, se l'attività principale ha android:resizeableActivity="true", tutte le attività nell'elenco di attività sono ridimensionabili. Su alcuni dispositivi più grandi, come i Chromebook, l'app potrebbe essere eseguita in una finestra ridimensionabile anche se specifichi android:resizeableActivity="false". Se questo causa un malfunzionamento dell'app, puoi utilizzare i filtri su Google Play per limitare la disponibilità della tua app su questi dispositivi.

Per Android 12 (livello API 31) è impostata per impostazione predefinita la modalità multi-finestra. Su schermi di grandi dimensioni (classe di dimensioni della finestra media o espandita), tutte le app vengono eseguite in modalità multi-finestra indipendentemente dalla configurazione dell'app. Su schermi di piccole dimensioni, il sistema controlla le impostazioni minWidth, minHeight e resizeableActivity di un'attività per determinare se può essere eseguita in modalità multifinestra.

resizeableActivity

Imposta questo attributo nell'elemento <activity> o <application> del file manifest per attivare o disattivare la modalità multi-finestra per il livello API 30 e versioni precedenti:

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

Se questo attributo è impostato su true, l'attività può essere avviata in modalità di finestra su desktop e schermo diviso. Se l'attributo è impostato su false, l'attività non supporta la modalità a più finestre. Se il valore è false e l'utente tenta di avviare l'attività in modalità a più finestre, l'attività assume il controllo dello schermo intero.

Se la tua app ha come target il livello API 24 o versioni successive, ma non specifichi un valore per questo attributo, il valore predefinito è true.

Se la tua app ha come target il livello API 31 o versioni successive, questo attributo funziona in modo diverso su schermi piccoli e grandi:

• Schermate grandi (classe di dimensioni della finestra media o estesa): tutte le app supportano la modalità multi-finestra. L'attributo indica se è possibile ridimensionare un'attività. Se resizeableActivity="false", l'app viene messa in modalità di compatibilità quando necessario per rispettare le dimensioni del display.
• Schermate piccole (classe di dimensioni della finestra compatta): se resizeableActivity="true" e la larghezza e l'altezza minima dell'attività rientrano nei requisiti per il multi-finestra, l'attività supporta la modalità multi-finestra. Se resizeableActivity="false", l'attività non supporta la modalità a più finestre, indipendentemente dalla larghezza e dall'altezza minime dell'attività.

supportsPictureInPicture

Imposta questo attributo nel nodo <activity> del manifest per indicare se l'attività supporta la modalità Picture in Picture.

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

configChanges

Per gestire autonomamente le modifiche alla configurazione multi-finestra, ad esempio quando un utente ridimensiona una finestra, aggiungi l'attributo android:configChanges al nodo <activity> del manifest dell'app con almeno i seguenti valori:

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

Dopo aver aggiunto android:configChanges, l'attività e i frammenti ricevono un callback a onConfigurationChanged() anziché essere distrutti e ricreati. Puoi quindi aggiornare manualmente le visualizzazioni, ricaricare le risorse ed eseguire altre operazioni in base alle tue esigenze.

<layout>

Su Android 7.0 (livello API 24) e versioni successive, l'elemento manifest <layout> supporta diversi attributi che influiscono sul comportamento di un'attività in modalità multi-finestra:

• android:defaultHeight, android:defaultWidth: altezza e larghezza predefinite dell'attività quando viene lanciata in modalità finestra del computer.

• android:gravity: posizionamento iniziale dell'attività quando viene avviata in modalità finestra del computer. Consulta la classe Gravity per i valori adatti.

• android:minHeight, android:minWidth: altezza e larghezza minime per l'attività nelle modalità schermo diviso e finestra del desktop. Se l'utente sposta il divisore in modalità schermo diviso per ridurre un'attività al di sotto del minimo specificato, il sistema ritaglia l'attività alle dimensioni richieste dall'utente.

Il seguente codice mostra come specificare le dimensioni e la posizione predefinite di un'attività nonché le dimensioni minime quando l'attività viene visualizzata in modalità finestra del desktop:

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

Modalità multi-finestra in fase di esecuzione

A partire da Android 7.0, il sistema offre funzionalità per supportare le app che possono essere eseguite in modalità a più finestre.

Funzionalità disattivate in modalità multi-finestra

In modalità multi-finestra, Android potrebbe disattivare o ignorare le funzionalità che non si applicano a un'attività che condivide lo schermo del dispositivo con altre attività o app.

Inoltre, alcune opzioni di personalizzazione dell'interfaccia utente di sistema sono disattivate. Ad esempio, le app non possono nascondere la barra di stato se sono in esecuzione in modalità multifinestra (consulta Controllare la visibilità dell'interfaccia utente di sistema).

Il sistema ignora le modifiche all'attributo android:screenOrientation.

Query e callback in modalità multi-finestra

La classe Activity offre i seguenti metodi per supportare la modalità multi-finestra:

• isInMultiWindowMode(): indica se l'attività è in modalità multi-finestra.

• isInPictureInPictureMode(): indica se l'attività è in modalità PiP.

• onMultiWindowModeChanged(): il sistema chiama questo metodo ogni volta che l'attività attiva o disattiva la modalità multifinestra. Il sistema passa al metodo un valore true se l'attività sta entrando in modalità multi-finestra o false se l'attività sta uscendo da questa modalità.

• onPictureInPictureModeChanged(): il sistema chiama questo metodo ogni volta che l'attività attiva o disattiva la modalità Picture in picture. Il sistema passa al metodo un valore true se l'attività entra in modalità Picture in picture o false se l'attività esce da questa modalità.

La classe Fragment espone le versioni di molti di questi metodi, ad esempio Fragment.onMultiWindowModeChanged().

Modalità Picture in picture

Per mettere un'attività in modalità Picture in picture, chiama enterPictureInPictureMode(). Questo metodo non ha alcun effetto se il dispositivo non supporta la modalità Picture in picture. Per saperne di più, consulta Aggiungere video utilizzando il formato picture in picture (PiP).

Nuove attività in modalità multi-finestra

Quando avvii una nuova attività, puoi indicare che deve essere visualizzata accanto a quella corrente, se possibile. Utilizza il flag di intent FLAG_ACTIVITY_LAUNCH_ADJACENT, che indica al sistema di provare a creare la nuova attività in una finestra adiacente, in modo che le due attività condividano lo schermo. Il sistema fa del suo meglio per farlo, ma non è garantito che ciò accada.

Se un dispositivo è in modalità finestra del desktop e stai avviando una nuova attività, puoi specificare le dimensioni e la posizione sullo schermo della nuova attività chiamando ActivityOptions.setLaunchBounds(). Il metodo non ha effetto se il dispositivo non è in modalità multi-finestra.

Con il livello API 30 e versioni precedenti, se avvii un'attività all'interno di uno stack di attività, questa sostituisce l'attività sullo schermo, ereditando tutte le sue proprietà di più finestre. Se vuoi avviare la nuova attività come finestra separata in modalità multi-finestra, devi avviarla in un nuovo stack di attività.

Android 12 (livello API 31) consente alle app di suddividere la finestra delle attività di un'applicazione tra più attività. Puoi determinare in che modo la tua app mostra le attività (a schermo intero, affiancate o impilate) creando un file di configurazione XML o eseguendo chiamate all'API Jetpack WindowManager.

Trascina

Gli utenti possono trascinare i dati da un'attività all'altra mentre le due attività condividono lo schermo. Prima di Android 7.0, gli utenti potevano trascinare i dati solo all'interno di un'unica attività. Per aggiungere rapidamente il supporto per l'accettazione contenuti eliminati, consulta l'API DropHelper. Per indicazioni complete sul trascinamento, consulta Attivare il trascinamento.

Multi-istanza

Ogni attività principale ha la propria attività, che viene eseguita in un processo separato e visualizzata nella propria finestra. Per avviare una nuova istanza della tua app in una finestra distinta, puoi avviare nuove attività con il flag FLAG_ACTIVITY_NEW_TASK. Puoi combinarlo con alcuni degli attributi multi-finestra per richiedere una posizione specifica per la nuova finestra. Ad esempio, un'app di shopping può mostrare più finestre per confrontare i prodotti.

Android 12 (livello API 31) ti consente di avviare due istanze di un'attività affiancate nella stessa finestra delle attività.

Se vuoi consentire agli utenti di avviare un'altra istanza della tua applicazione dal avviatore delle applicazioni o dalla barra delle app, assicurati che l'attività dell'avviatore sia impostata su android:resizeableActivity="true" e che non utilizzi una modalità di avvio che impedisca l'uso di più istanze. Ad esempio, un'attività singleInstancePerTask può essere creata più volte in attività diverse quando è impostato FLAG_ACTIVITY_MULTIPLE_TASK o FLAG_ACTIVITY_NEW_DOCUMENT.

Non confondere la multiistanza con un layout a più riquadri, ad esempio una presentazione elenco-dettaglio che utilizza SlidingPaneLayout ed è eseguita in un'unica finestra.

Tieni presente che, quando sono in esecuzione più istanze in finestre separate su un dispositivo pieghevole, una o più istanze potrebbero essere inviate in background se la posizione cambia. Ad esempio, supponiamo che un dispositivo sia aperto e abbia due istanze dell'app in esecuzione in due finestre su entrambi i lati della piega. Se il dispositivo è chiuso, una delle istanze potrebbe essere interrotta anziché cercare di adattare le finestre di entrambe le istanze a uno schermo più piccolo.

Verifica della modalità multi-finestra

Indipendentemente dal fatto che la tua app abbia come target il livello API 24 o versioni successive, devi verificare il suo comportamento in modalità multifinestra nel caso in cui un utente provi ad avviarla in questa modalità su un dispositivo con Android 7.0 o versioni successive.

Prova dispositivi

I dispositivi con Android 7.0 (livello API 24) o versioni successive supportano la modalità a più finestre.

Livello API 23 o precedente

Quando gli utenti tentano di utilizzare l'app in modalità multi-finestra, il sistema ridimensiona forzatamente l'app, a meno che l'app non dichiari un orientamento fisso.

Se la tua app non dichiara un'inclinazione fissa, devi avviarla su un dispositivo con Android 7.0 o versioni successive e provare a metterla in modalità schermo diviso. Verifica che l'esperienza utente sia accettabile quando le dimensioni dell'app vengono modificate forzatamente.

Se l'app dichiara un orientamento fisso, dovresti provare a metterla in modalità multi-finestra. Verifica che, quando lo fai, l'app rimanga in modalità a schermo intero.

Livelli API da 24 a 30

Se la tua app ha come target i livelli API da 24 a 30 e non disattiva il supporto del multi-finestra, verifica il seguente comportamento sia in modalità schermo diviso che in modalità finestra da desktop:

• Avvia l'app a schermo intero, quindi passa alla modalità a più finestre premendo a lungo il tasto Recenti. Verifica che l'app passi correttamente.

• Avvia l'app direttamente in modalità multi-finestra e verifica che si avvii correttamente. Puoi avviare un'app in modalità multi-finestra premendo il pulsante Recenti, quindi premendo a lungo la barra del titolo dell'app e trascinandola in una delle aree evidenziate sullo schermo.

• Modifica le dimensioni dell'app in modalità schermo diviso trascinando il divisore dello schermo. Verifica che l'app cambi le dimensioni senza arresti anomali e che gli elementi dell'interfaccia utente necessari siano visibili.

• Se hai specificato dimensioni minime per l'app, prova a ridimensionarla in modo che le dimensioni della finestra siano inferiori a queste dimensioni. Verifica che non sia possibile ridimensionare l'app in modo che sia più piccola delle dimensioni minime specificate.

• Durante tutti i test, verifica che il rendimento della tua app sia accettabile. Ad esempio, verifica che non ci sia un ritardo troppo lungo per l'aggiornamento dell'interfaccia utente dopo la modifica delle dimensioni dell'app.

Livello API 31 o versioni successive

Se la tua app ha come target il livello API 31 o versioni successive e la larghezza minima e l'altezza minima dell'attività principale sono inferiori o uguali alle rispettive dimensioni dell'area di visualizzazione disponibile, verifica tutti i comportamenti elencati per i livelli API da 24 a 30.

Elenco di controllo per i test

Per verificare le prestazioni della tua app in modalità multi-finestra, prova le seguenti operazioni. Ti consigliamo di provare queste operazioni sia in modalità schermo diviso sia in modalità finestra del computer, salvo diversa indicazione.

• Attiva e disattiva la modalità multi-finestra.

• Passa dalla tua app a un'altra e verifica che l'app si comporti correttamente quando è visibile, ma non attiva. Ad esempio, se la tua app riproduce un video, verifica che la riproduzione continui mentre l'utente interagisce con un'altra app.

• In modalità schermo diviso, prova a spostare il divisore dello schermo per ingrandire e rimpicciolire l'app. Prova queste operazioni sia affiancate sia una sopra l'altra. Verifica che l'app non abbia arresti anomali, che le funzionalità essenziali siano visibili e che l'operazione di ridimensionamento non richieda troppo tempo.

• Esegui diverse operazioni di ridimensionamento in rapida successione. Verifica che l'app non abbia arresti anomali o perdite di memoria. Lo strumento di analisi della memoria di Android Studio fornisce informazioni sull'utilizzo della memoria dell'app (consulta Esaminare l'utilizzo della memoria dell'app con lo strumento di analisi della memoria).

• Utilizza normalmente l'app in una serie di configurazioni diverse della finestra e verifica che l'app funzioni correttamente. Verifica che il testo sia leggibile e che gli elementi dell'interfaccia utente non siano troppo piccoli per interagire.

Supporto della funzionalità Multi-finestra disattivato

Nei livelli API da 24 a 30, se hai disattivato il supporto multi-finestra impostando android:resizeableActivity="false", devi avviare l'app su un dispositivo con Android da 7.0 a 11 e provare a metterla in modalità schermo diviso e in modalità finestra desktop. Verifica che l'app rimanga in modalità schermo intero.

Risorse aggiuntive

Per ulteriori informazioni sul supporto della funzionalità Multi-finestra in Android, consulta:

• Esempio di MultiWindowPlayground per Android