A partire da Android 12,
L'API SplashScreen
consente l'avvio delle app
con animazione, tra cui un'azione in-app al momento del lancio e una schermata iniziale che mostra
l'icona dell'app e una transizione all'app stessa. Un SplashScreen
è un
Window
e
pertanto copre
Activity
.
L'esperienza della schermata iniziale aggiunge elementi di design standard a ogni app ma è anche personalizzabile, in modo che la tua app mantenga il proprio branding unico.
Oltre a utilizzare l'API della piattaforma SplashScreen
, puoi utilizzare anche l'API
SplashScreen
compat, che aggrega l'API SplashScreen
.
Come funziona la schermata iniziale
Quando un utente avvia un'app mentre il processo della stessa non è in esecuzione (un
) oppure Activity
non
creato (un avvio rapido),
si verificano i seguenti eventi:
Il sistema mostra la schermata iniziale utilizzando temi ed eventuali animazioni definire.
Quando l'app è pronta, la schermata iniziale viene chiusa e l'app viene visualizzata.
La schermata iniziale non viene mai visualizzata durante avvio rapido.
Elementi e meccanismi della schermata iniziale
Gli elementi della schermata iniziale sono definiti dai file di risorse XML nella File manifest di Android. Esistono versioni delle modalità Luce e Buio per ogni elemento.
Gli elementi personalizzabili di una schermata iniziale sono costituiti dall'icona dell'app e dall'icona e sfondo della finestra:
![Un'immagine che mostra gli elementi contenuti in una schermata iniziale](https://developer.android.com/static/images/guide/topics/ui/splash-screen/splash-screen-composition.png?authuser=0000&hl=it)
Considera i seguenti elementi, mostrati nella Figura 2:
1 L'icona dell'app deve essere disegnabile vettoriale. it può essere statico o animato. Sebbene le animazioni possano avere una durata illimitata, consigliamo di non superare i 1000 millisecondi. L'icona in Avvio applicazioni è l'icona predefinita.
2 Lo sfondo dell'icona è facoltativo e utile se occorre un maggiore contrasto tra l'icona e lo sfondo della finestra. Se utilizzi un adattiva, le relative lo sfondo viene visualizzato se il contrasto è sufficiente con lo sfondo della finestra.
3 Come per le icone adattive, un terzo del il primo piano è mascherato.
4 Lo sfondo della finestra è costituito da una singola colore opaco. Se lo sfondo della finestra è impostato ed è di un colore a tinta unita, viene utilizzato per impostazione predefinita se l'attributo non è impostato.
Dimensioni schermata iniziale
L'icona della schermata iniziale utilizza le stesse specifiche icone adattive, come segue:
- Immagine con brand: le dimensioni devono essere 200 × 80 dp.
- Icona dell'app con sfondo di un'icona: deve essere di 240 × 240 dp e rientrare in una cerchio con un diametro di 160 dp.
- Icona dell'app senza sfondo icona: deve avere dimensioni di 288 × 288 dp e rientrare un cerchio con un diametro di 192 dp.
Ad esempio, se la dimensione intera di un'immagine è 300 × 300 dp, l'icona deve adattarsi all'interno di un cerchio con un diametro di 200 dp. Tutto al di fuori del cerchio gira invisibile (mascherata).
![Un'immagine che mostra icone di dimensioni diverse per uno sfondo in tinta unita e trasparente](https://developer.android.com/static/images/guide/topics/ui/splash-screen/splash-screen-icon-dimensions.png?authuser=0000&hl=it)
Animazioni della schermata iniziale e sequenza di avvio
Una latenza aggiuntiva è spesso associata all'avvio di un'app con un avvio a freddo. L'aggiunta di un'icona animata alla schermata iniziale ha un evidente fascino estetico e offre un'esperienza di livello superiore. Una ricerca sugli utenti mostra che la percezione di una startup è inferiore quando si visualizza un'animazione.
Un'animazione della schermata iniziale è incorporata nei componenti della sequenza di avvio, come mostrato nella figura 4.
![Un'immagine che mostra la sequenza di avvio in dodici frame consecutivi, a partire dal tocco dell'icona di avvio, che riempie lo schermo mentre si ingrandisce](https://developer.android.com/static/images/ui/splash-sequence.png?authuser=0000&hl=it)
Inserisci l'animazione: dalla visualizzazione del sistema alla schermata iniziale. it è controllato dal sistema e non è personalizzabile.
Schermata iniziale (mostrata durante la parte di attesa della sequenza): la schermata iniziale la schermata può essere personalizzata, consentendoti di fornire l'animazione del tuo logo e branding. Deve soddisfare i requisiti descritto in questa pagina per funzionare correttamente.
Esci dall'animazione: consiste nell'animazione che nasconde la schermata iniziale. Se vuoi personalizzarla, utilizza il
SplashScreenView
e le relative . Puoi eseguire qualsiasi animazione, con impostazioni per Transform, opacità e colore. In questo caso, rimuovi manualmente la schermata iniziale quando al termine dell'animazione.
Durante l'esecuzione dell'animazione dell'icona, l'avvio dell'app ti offre la possibilità di ignorare
nei casi in cui l'app sia già pronta. L'app attiva onResume()
o il timeout della schermata iniziale si verifica automaticamente, quindi assicurati che il movimento
saltati comodamente. La schermata iniziale deve essere ignorata soltanto con onResume()
quando l'app è stabile dal punto di vista visivo, in modo che non vengano
necessaria. L'introduzione di un'interfaccia incompleta può essere fastidiosa per gli utenti e potrebbe
diano un'impressione di imprevedibilità o mancanza di smalto.
Requisiti per l'animazione della schermata iniziale
La schermata iniziale deve rispettare le seguenti specifiche:
Imposta il colore di sfondo di una singola finestra senza trasparenza. Giorno e notte sono supportate Libreria compatibile di
SplashScreen
.Assicurati che l'icona animata soddisfi le seguenti specifiche:
- Formato: l'icona deve essere una AnimatedVectorDrawable (Durata di visualizzazione media) XML.
- Dimensioni: un'icona di visualizzazione media della durata di visualizzazione deve essere quattro volte superiore a quella di un'immagine adattiva
come segue:
- .
- L'area dell'icona deve essere di 432 dp, ovvero quattro volte Area di 108 dp di un'icona adattiva non mascherata.
- I due terzi interni dell'immagine sono visibili sull'icona in Avvio applicazioni, e deve essere di 288 dp, ovvero quattro volte i 72 dp che costituisce l'area interna mascherata di un'icona adattiva.
- Durata: consigliamo di non superare i 1000 ms sugli smartphone. Puoi utilizzare un avvio ritardato, ma non può superare i 166 ms. Se l'app sia superiore a 1000 ms, prendi in considerazione un'animazione in loop.
Stabilisci un momento appropriato per chiudere la schermata iniziale, che avviene quando l'app disegna il primo frame. Puoi personalizzare ulteriormente questa impostazione come descritto nella sezione su mantenere la schermata iniziale sullo schermo per periodi più lunghi.
Risorse della schermata iniziale
Scarica starter kit di esempio, che illustra come creare, formattare ed esportare un'animazione in una durata di visualizzazione media. Comprende quanto segue:
- Il file di progetto Adobe After Effects dell'animazione.
- File XML AVD finale esportato.
- GIF di esempio dell'animazione.
Se scarichi questi file, accetti i Termini di servizio di Google.
Le Norme sulla privacy di Google descrivono come all'interno di questo servizio.
Personalizza la schermata iniziale nell'app
Per impostazione predefinita, SplashScreen
utilizza la windowBackground
del tuo tema se
windowBackground
è un solo colore. Per personalizzare la schermata iniziale, aggiungi
attributi al tema dell'app.
Puoi personalizzare la schermata iniziale della tua app in uno dei seguenti modi:
Imposta gli attributi del tema per modificarne l'aspetto.
Tienilo sullo schermo per un periodo più lungo.
Personalizza l'animazione per chiudere la schermata iniziale.
Inizia
La raccolta principale di SplashScreen
offre la schermata iniziale di Android 12 su tutti
dall'API 23. Per aggiungerlo al tuo progetto, aggiungi il seguente snippet a
il tuo file build.gradle
:
Alla moda
dependencies { implementation "androidx.core:core-splashscreen:1.0.0" }
Kotlin
dependencies { implementation("androidx.core:core-splashscreen:1.0.0") }
Imposta un tema per la schermata iniziale di cui modificare l'aspetto
Puoi specificare i seguenti attributi nel tema Activity
da personalizzare
la schermata iniziale dell'app. Se hai già una schermata iniziale precedente
che utilizza attributi come android:windowBackground
, prendi in considerazione
fornendo un file di risorse alternativo per Android 12 e versioni successive.
Utilizza le funzionalità di
windowSplashScreenBackground
per riempire lo sfondo con un colore specifico:<item name="android:windowSplashScreenBackground">@color/...</item>
Utilizza le funzionalità di
windowSplashScreenAnimatedIcon
per sostituire l'icona al centro della finestra iniziale.Per le app che hanno come target solo Android 12 (livello API 32), procedi nel seguente modo:
Se l'oggetto è animabile e disegnabile tramite
AnimationDrawable
eAnimatedVectorDrawable
, impostawindowSplashScreenAnimationDuration
su consente di riprodurre l'animazione mostrando la finestra iniziale. Non è obbligatorio per Android 13, perché la durata viene dedotta direttamenteAnimatedVectorDrawable
.<item name="android:windowSplashScreenAnimatedIcon">@drawable/...</item>
Utilizza le funzionalità di
windowSplashScreenAnimationDuration
per indicare la durata dell'animazione dell'icona della schermata iniziale. L'impostazione non influisce sul tempo effettivo durante il quale viene visualizzata la schermata iniziale ma puoi recuperarla quando personalizzi l'uscita dalla schermata iniziale utilizzandoSplashScreenView.getIconAnimationDuration
Consulta la sezione seguente su mantenere la schermata iniziale sullo schermo per periodi più lunghi per ulteriori informazioni.<item name="android:windowSplashScreenAnimationDuration">1000</item>
Utilizza
windowSplashScreenIconBackgroundColor
per impostare uno sfondo dietro l'icona della schermata iniziale. È utile se ci sono non sia sufficiente il contrasto tra lo sfondo della finestra e l'icona.<item name="android:windowSplashScreenIconBackgroundColor">@color/...</item>
Puoi utilizzare
windowSplashScreenBrandingImage
per impostare un'immagine da mostrare nella parte inferiore della schermata iniziale. Tuttavia, le linee guida per la progettazione sconsigliano l'utilizzo di un'immagine di branding.<item name="android:windowSplashScreenBrandingImage">@drawable/...</item>
Puoi utilizzare
windowSplashScreenBehavior
per specificare se la tua app deve sempre visualizzare l'icona nella schermata iniziale in Android 13 e versioni successive. Il valore predefinito è 0 e viene visualizzata l'icona la schermata iniziale se l'attività di avvio impostasplashScreenStyle
suSPLASH_SCREEN_STYLE_ICON
, o segue il comportamento del sistema se l'attività di avvio non specifica lo stile del testo. Se preferisci non visualizzare mai una schermata iniziale vuota e vuoi sempre l'icona animata da visualizzare, imposta il valoreicon_preferred
.<item name="android:windowSplashScreenBehavior">icon_preferred</item>
Mantieni la schermata iniziale sullo schermo per periodi più lunghi
La schermata iniziale viene ignorata non appena l'app apre il primo frame. Se
devi caricare una piccola quantità di dati, ad esempio le impostazioni in-app da un
disco locale in modo asincrono, puoi utilizzare
ViewTreeObserver.OnPreDrawListener
sospendere l'app e disegnare il primo frame.
Se l'attività iniziale termina prima di disegnare, ad esempio, non
impostare la visualizzazione dei contenuti e terminarla prima del giorno onResume
—il pre-disegno
non serve.
Kotlin
// Create a new event for the activity. override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Set the layout for the content view. setContentView(R.layout.main_activity) // Set up an OnPreDrawListener to the root view. val content: View = findViewById(android.R.id.content) content.viewTreeObserver.addOnPreDrawListener( object : ViewTreeObserver.OnPreDrawListener { override fun onPreDraw(): Boolean { // Check whether the initial data is ready. return if (viewModel.isReady) { // The content is ready. Start drawing. content.viewTreeObserver.removeOnPreDrawListener(this) true } else { // The content isn't ready. Suspend. false } } } ) }
Java
// Create a new event for the activity. @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Set the layout for the content view. setContentView(R.layout.main_activity); // Set up an OnPreDrawListener to the root view. final View content = findViewById(android.R.id.content); content.getViewTreeObserver().addOnPreDrawListener( new ViewTreeObserver.OnPreDrawListener() { @Override public boolean onPreDraw() { // Check whether the initial data is ready. if (mViewModel.isReady()) { // The content is ready. Start drawing. content.getViewTreeObserver().removeOnPreDrawListener(this); return true; } else { // The content isn't ready. Suspend. return false; } } }); }
Personalizza l'animazione per chiudere la schermata iniziale
Puoi personalizzare ulteriormente l'animazione della schermata iniziale tramite
Activity.getSplashScreen()
Kotlin
override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // ... // Add a callback that's called when the splash screen is animating to the // app content. splashScreen.setOnExitAnimationListener { splashScreenView -> // Create your custom animation. val slideUp = ObjectAnimator.ofFloat( splashScreenView, View.TRANSLATION_Y, 0f, -splashScreenView.height.toFloat() ) slideUp.interpolator = AnticipateInterpolator() slideUp.duration = 200L // Call SplashScreenView.remove at the end of your custom animation. slideUp.doOnEnd { splashScreenView.remove() } // Run your animation. slideUp.start() } }
Java
@Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); // ... // Add a callback that's called when the splash screen is animating to the // app content. getSplashScreen().setOnExitAnimationListener(splashScreenView -> { final ObjectAnimator slideUp = ObjectAnimator.ofFloat( splashScreenView, View.TRANSLATION_Y, 0f, -splashScreenView.getHeight() ); slideUp.setInterpolator(new AnticipateInterpolator()); slideUp.setDuration(200L); // Call SplashScreenView.remove at the end of your custom animation. slideUp.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { splashScreenView.remove(); } }); // Run your animation. slideUp.start(); }); }
All'inizio di questo callback,
Drawable vettoriale animato
nella schermata iniziale. A seconda della durata del lancio dell'app,
drawable potrebbe trovarsi al centro dell'animazione. Utilizza le funzionalità di
SplashScreenView.getIconAnimationStart
per sapere quando è stata avviata l'animazione. Puoi calcolare la durata rimanente
l'animazione dell'icona nel seguente modo:
Kotlin
// Get the duration of the animated vector drawable. val animationDuration = splashScreenView.iconAnimationDuration // Get the start time of the animation. val animationStart = splashScreenView.iconAnimationStart // Calculate the remaining duration of the animation. val remainingDuration = if (animationDuration != null && animationStart != null) { (animationDuration - Duration.between(animationStart, Instant.now())) .toMillis() .coerceAtLeast(0L) } else { 0L }
Java
// Get the duration of the animated vector drawable. Duration animationDuration = splashScreenView.getIconAnimationDuration(); // Get the start time of the animation. Instant animationStart = splashScreenView.getIconAnimationStart(); // Calculate the remaining duration of the animation. long remainingDuration; if (animationDuration != null && animationStart != null) { remainingDuration = animationDuration.minus( Duration.between(animationStart, Instant.now()) ).toMillis(); remainingDuration = Math.max(remainingDuration, 0L); } else { remainingDuration = 0L; }
Risorse aggiuntive
- Esegui la migrazione dell'implementazione della schermata iniziale esistente ad Android 12 e in più
- Ora nell'app Android, che mostra l'implementazione reale di una schermata iniziale