Meta description: In questa guida scoprirai come aggiungere e personalizzare la Toolbar in Android Studio con Java. Si tratta di una guida completa con esempi di codice, menu, icone e una mini app di esempio.
Toolbar Android in Android Studio – Guida Completa
In questa guida vedrai passo passo come usare la Toolbar Android in Android Studio con Java, dalla configurazione di base fino a una mini app completa con menu, icone e Toast. Inoltre, la guida è pensata per sviluppatori principianti e intermedi che vogliono sostituire o migliorare la vecchia ActionBar Android.
1. Introduzione alla Toolbar Android
La Toolbar Android è un widget flessibile introdotto per sostituire e superare la classica ActionBar Android. In altre parole, a differenza dell’ActionBar, la Toolbar è un normale ViewGroup che puoi inserire in qualsiasi posizione del layout (non solo in cima alla finestra) e puoi personalizzare molto più facilmente.
Per questo motivo è utile conoscere i vantaggi principali della Toolbar rispetto all’ActionBar:
- È un widget come gli altri: puoi posizionarla dove vuoi nel layout.
- È altamente personalizzabile: colori, font, logo, icone, menu, vista personalizzata.
- Supporta la navigazione (icona back, drawer, ecc.) con le stesse API di AppCompat.
- Funziona bene con le Material Design guidelines e con il pattern di AppBar/Toolbar ufficiale.
2. Prerequisiti per usare la Toolbar Android
Per seguire questa guida pratica ti serve innanzitutto:
- Android Studio installato (qualsiasi versione recente).
- Un progetto Android che utilizza le librerie AndroidX AppCompat.
- Conoscenza base di Java e dei layout XML di Android.
Prima di procedere, assicurati che nel tuo build.gradle (Module: app) siano presenti le dipendenze AppCompat. Un esempio minimo:
dependencies {
implementation 'androidx.appcompat:appcompat:1.6.1'
implementation 'com.google.android.material:material:1.11.0'
// Altre dipendenze...
}3. Aggiungere la Toolbar Android al layout XML
Per usare la Toolbar devi prima inserirla nel layout XML dell’activity, ad esempio in res/layout/activity_main.xml. In questo modo useremo androidx.appcompat.widget.Toolbar con alcuni attributi di stile, colore ed elevazione.
Esempio di activity_main.xml con Toolbar Android
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<com.google.android.material.appbar.AppBarLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar">
<androidx.appcompat.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"
android:background="@color/purple_500"
android:elevation="4dp"
app:popupTheme="@style/ThemeOverlay.AppCompat.Light"
app:titleTextColor="@android:color/white"
app:subtitleTextColor="@android:color/white" />
</com.google.android.material.appbar.AppBarLayout>
<FrameLayout
android:id="@+id/content_frame"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_marginTop="?attr/actionBarSize" />
</androidx.coordinatorlayout.widget.CoordinatorLayout>
In questo esempio, come vedremo tra poco, la configurazione si basa su alcuni attributi chiave:
android:backgroundusa il colore principale del tema.android:elevationaggiunge un’ombra sotto la Toolbar.app:titleTextColoreapp:subtitleTextColorimpostano il colore del testo (bianco).
4. Configurare la Toolbar Android in Java
Ora colleghiamo la Toolbar al codice Java e la impostiamo come ActionBar dell’activity usando setSupportActionBar(toolbar). A tal fine, eseguiremo la configurazione direttamente in MainActivity.java.
Esempio di MainActivity.java con Toolbar Android
package com.example.myapp;
import android.os.Bundle;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 1. Troviamo la Toolbar nel layout
Toolbar toolbar = findViewById(R.id.toolbar);
// 2. Impostiamo la Toolbar come ActionBar dell'activity
setSupportActionBar(toolbar);
// 3. Impostiamo titolo e sottotitolo
if (getSupportActionBar() != null) {
getSupportActionBar().setTitle("Titolo Toolbar");
getSupportActionBar().setSubtitle("Sottotitolo Toolbar");
}
// 4. Impostiamo icona di navigazione (ad esempio una freccia indietro)
toolbar.setNavigationIcon(androidx.appcompat.R.drawable.abc_ic_ab_back_material);
// 5. Listener per il click sull'icona di navigazione
toolbar.setNavigationOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// Azione quando si clicca sull'icona di navigazione
onBackPressed();
}
});
}
}In questo modo la Toolbar si comporta come una normale ActionBar, ma con molta più flessibilità di personalizzazione rispetto alla soluzione tradizionale.
5. Aggiungere un Menu alla Toolbar Android
Uno degli usi più comuni è mostrare un menu con azioni come Cerca, Impostazioni o Info. Per questo motivo useremo un file XML nella cartella res/menu e il codice Java per gestire i click (pattern tipico in Java).
Creare il file XML del menu (menu_toolbar.xml)
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<item
android:id="@+id/action_search"
android:title="Cerca"
android:icon="@android:drawable/ic_menu_search"
app:showAsAction="ifRoom|withText" />
<item
android:id="@+id/action_settings"
android:title="Impostazioni"
android:icon="@android:drawable/ic_menu_manage"
app:showAsAction="never" />
<item
android:id="@+id/action_info"
android:title="Info"
android:icon="@android:drawable/ic_menu_info_details"
app:showAsAction="never" />
</menu>Gestire il menu della Toolbar Android in Java
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_toolbar, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
int id = item.getItemId();
if (id == R.id.action_search) {
// TODO: azione di ricerca
return true;
} else if (id == R.id.action_settings) {
// TODO: apri impostazioni
return true;
} else if (id == R.id.action_info) {
// TODO: mostra info
return true;
}
return super.onOptionsItemSelected(item);
}Con questi metodi il menu viene visualizzato nella Toolbar e puoi reagire ai click sulle singole voci in modo chiaro e strutturato.
6. Personalizzare la Toolbar Android
La Toolbar è pensata per essere personalizzata. Di conseguenza, di seguito trovi alcuni esempi pratici per cambiare colore di sfondo, colore del testo e aggiungere un logo, sia via XML che via Java.
Personalizzare la Toolbar Android via XML
<androidx.appcompat.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"
android:background="@color/purple_500"
app:titleTextColor="@android:color/white"
app:subtitleTextColor="@android:color/white"
app:logo="@mipmap/ic_launcher_round" />In questo caso la Toolbar usa un colore di sfondo personalizzato (@color/purple_500), un logo e testo bianco per titolo e sottotitolo, in modo da migliorare la leggibilità.
Personalizzare la Toolbar Android via Java
Toolbar toolbar = findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
if (getSupportActionBar() != null) {
getSupportActionBar().setTitle("Titolo personalizzato");
getSupportActionBar().setSubtitle("Sottotitolo personalizzato");
getSupportActionBar().setLogo(R.mipmap.ic_launcher_round);
}
// Cambia il colore di sfondo a runtime
toolbar.setBackgroundColor(getResources().getColor(R.color.purple_500));
// Cambia il colore del titolo
// Per API moderne è consigliato usare ContextCompat.getColor
toolbar.setTitleTextColor(getResources().getColor(android.R.color.white));
toolbar.setSubtitleTextColor(getResources().getColor(android.R.color.white));Questi esempi ti permettono di controllare l’aspetto della Toolbar direttamente dal codice, utile per cambiare stile in base allo stato dell’app o al tema scelto dall’utente. Come risultato, puoi adattare facilmente la UI a contesti diversi.
7. Mini app completa con Toolbar Android
Vediamo ora una mini app completa che utilizza la Toolbar in modo pratico. Prima di tutto, ecco i requisiti:
- Toolbar con titolo “La Mia App”.
- Menu con 3 voci: Profilo, Impostazioni, Esci.
- Al click su ogni voce viene mostrato un
Toastcon il nome della voce selezionata.
7.1 Layout XML per la Toolbar Android
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<com.google.android.material.appbar.AppBarLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar">
<androidx.appcompat.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"
android:background="@color/purple_500"
android:elevation="4dp"
app:popupTheme="@style/ThemeOverlay.AppCompat.Light"
app:titleTextColor="@android:color/white" />
</com.google.android.material.appbar.AppBarLayout>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical">
<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Contenuto principale dell'app"
android:textSize="18sp" />
</LinearLayout>
</androidx.coordinatorlayout.widget.CoordinatorLayout>7.2 Menu della Toolbar Android: menu_toolbar.xml
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<item
android:id="@+id/action_profile"
android:title="Profilo"
android:icon="@android:drawable/ic_menu_myplaces"
app:showAsAction="ifRoom" />
<item
android:id="@+id/action_settings"
android:title="Impostazioni"
android:icon="@android:drawable/ic_menu_manage"
app:showAsAction="never" />
<item
android:id="@+id/action_logout"
android:title="Esci"
android:icon="@android:drawable/ic_lock_power_off"
app:showAsAction="never" />
</menu>7.3 Activity Java con Toolbar Android: MainActivity.java
package com.example.myapp;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Colleghiamo la Toolbar dal layout
Toolbar toolbar = findViewById(R.id.toolbar);
// Impostiamo la Toolbar come ActionBar
setSupportActionBar(toolbar);
// Impostiamo il titolo
if (getSupportActionBar() != null) {
getSupportActionBar().setTitle("La Mia App");
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Gonfiamo il menu nella Toolbar
getMenuInflater().inflate(R.menu.menu_toolbar, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
int id = item.getItemId();
if (id == R.id.action_profile) {
showToast("Profilo");
return true;
} else if (id == R.id.action_settings) {
showToast("Impostazioni");
return true;
} else if (id == R.id.action_logout) {
showToast("Esci");
return true;
}
return super.onOptionsItemSelected(item);
}
private void showToast(String message) {
Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
}
}Avviando l’app vedrai la Toolbar con il titolo “La Mia App” e il menu con tre voci. In questo modo, cliccando sulle voci comparirà un Toast con il nome corrispondente.
Aggiungere una SearchView alla Toolbar Android (ricerca in tempo reale)
Un pattern molto comune è integrare una SearchView direttamente nella Toolbar per filtrare contenuti in tempo reale (lista, RecyclerView, ecc.). Il flusso tipico è: definire una voce di menu con actionViewClass, recuperare la SearchView in onCreateOptionsMenu() e ascoltare le modifiche di testo.
1. Voce di menu con SearchView
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<item
android:id="@+id/action_search"
android:title="Cerca"
android:icon="@android:drawable/ic_menu_search"
app:showAsAction="ifRoom|collapseActionView"
app:actionViewClass="androidx.appcompat.widget.SearchView" />
</menu>2. Gestire la SearchView in Java (ricerca in tempo reale)
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_toolbar, menu);
MenuItem searchItem = menu.findItem(R.id.action_search);
SearchView searchView = (SearchView) searchItem.getActionView();
// Opzionale: suggerisci il tipo di input
searchView.setQueryHint("Cerca elementi...");
// Listener per la ricerca in tempo reale
searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String query) {
// Invocato quando l'utente preme invio/submit
filtraLista(query);
return true;
}
@Override
public boolean onQueryTextChange(String newText) {
// Invocato ad ogni cambio di testo (ricerca in tempo reale)
filtraLista(newText);
return true;
}
});
return true;
}
private void filtraLista(String testo) {
// TODO: Filtra la tua lista/RecyclerView in base al testo
// ad esempio usando un adapter.filter(testo)
}In un RecyclerView tipico, questa funzione richiama un adattatore che implementa Filterable o applica un filtro manuale alla lista dei dati, aggiornando la UI ad ogni modifica della query.
Toolbar Android collassabile con CollapsingToolbarLayout
Per ottenere una Toolbar collassabile in stile Material Design (immagine grande che si riduce e titolo che passa nella Toolbar durante lo scroll) si usa CollapsingToolbarLayout all’interno di un AppBarLayout. Questo pattern è ideale per schermate di dettaglio (ad esempio dettaglio prodotto, profilo utente, ecc.).
1. Layout XML con CollapsingToolbarLayout
<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".DetailActivity">
<com.google.android.material.appbar.AppBarLayout
android:id="@+id/appBarLayout"
android:layout_width="match_parent"
android:layout_height="300dp"
android:fitsSystemWindows="true">
<com.google.android.material.appbar.CollapsingToolbarLayout
android:id="@+id/collapsingToolbar"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fitsSystemWindows="true"
app:contentScrim="@color/purple_500"
app:expandedTitleMarginStart="48dp"
app:expandedTitleMarginEnd="64dp"
app:layout_scrollFlags="scroll|exitUntilCollapsed">
<ImageView
android:id="@+id/imageHeader"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:scaleType="centerCrop"
android:src="@drawable/header_image"
android:fitsSystemWindows="true"
app:layout_collapseMode="parallax" />
<androidx.appcompat.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"
app:layout_collapseMode="pin"
app:popupTheme="@style/ThemeOverlay.AppCompat.Light" />
</com.google.android.material.appbar.CollapsingToolbarLayout>
</com.google.android.material.appbar.AppBarLayout>
<androidx.core.widget.NestedScrollView
android:layout_width="match_parent"
android:layout_height="match_parent"
app:layout_behavior="@string/appbar_scrolling_view_behavior">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<!-- Contenuto della pagina -->
</LinearLayout>
</androidx.core.widget.NestedScrollView>
</androidx.coordinatorlayout.widget.CoordinatorLayout>2. Configurazione in Java
public class DetailActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_detail);
Toolbar toolbar = findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
CollapsingToolbarLayout collapsingToolbar = findViewById(R.id.collapsingToolbar);
collapsingToolbar.setTitle("Titolo espanso");
// Abilita il bottone back
if (getSupportActionBar() != null) {
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
}
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
if (item.getItemId() == android.R.id.home) {
onBackPressed();
return true;
}
return super.onOptionsItemSelected(item);
}
}La combinazione di CoordinatorLayout, AppBarLayout e CollapsingToolbarLayout si occupa automaticamente delle animazioni di scroll e del passaggio dal titolo espanso a quello collassato nella Toolbar.
Cambiare dinamicamente il colore della Toolbar Android in base allo scroll
Un effetto visivo interessante è far cambiare colore (o opacità) alla Toolbar mentre l’utente scorre il contenuto. Possiamo ottenere questo agganciandoci agli eventi di scroll dell’AppBarLayout o del contenuto e interpolando il colore in base alla percentuale di scroll.
1. Listener su AppBarLayout
public class MainActivity extends AppCompatActivity {
private Toolbar toolbar;
private AppBarLayout appBarLayout;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
toolbar = findViewById(R.id.toolbar);
appBarLayout = findViewById(R.id.appBarLayout);
setSupportActionBar(toolbar);
final int colorTrasparente = Color.TRANSPARENT;
final int colorFinale = ContextCompat.getColor(this, R.color.purple_500);
appBarLayout.addOnOffsetChangedListener(new AppBarLayout.OnOffsetChangedListener() {
@Override
public void onOffsetChanged(AppBarLayout appBarLayout, int verticalOffset) {
int range = appBarLayout.getTotalScrollRange();
float percent = Math.abs(verticalOffset) / (float) range;
int newColor = (Integer) new ArgbEvaluator().evaluate(percent, colorTrasparente, colorFinale);
toolbar.setBackgroundColor(newColor);
}
});
}
}Con questo approccio la Toolbar parte trasparente e diventa gradualmente del colore desiderato quando l’utente scorre verso l’alto. Lo stesso pattern può essere applicato ad altre proprietà (ad esempio l’alpha delle icone o la visibilità del titolo).
Aggiungere badge e notifiche alle icone della Toolbar Android
Per mostrare un badge numerico (ad esempio il numero di notifiche o messaggi) sopra un’icona nella Toolbar, il metodo più semplice è usare una actionView personalizzata per la voce di menu. All’interno della view possiamo posizionare un ImageView o ImageButton e un TextView per il badge.
1. Layout del badge (menu_badge_layout.xml)
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
<ImageButton
android:id="@+id/btnNotifications"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:background="@android:color/transparent"
android:src="@drawable/ic_notifications" />
<TextView
android:id="@+id/textBadge"
android:layout_width="18dp"
android:layout_height="18dp"
android:layout_gravity="end|top"
android:background="@drawable/bg_badge_red"
android:gravity="center"
android:text="0"
android:textColor="@android:color/white"
android:textSize="10sp" />
</FrameLayout>2. Voce di menu con actionLayout
<item
android:id="@+id/action_notifications"
android:title="Notifiche"
app:showAsAction="always"
app:actionLayout="@layout/menu_badge_layout" />3. Aggiornare il badge in Java
private TextView textBadge;
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_toolbar, menu);
MenuItem item = menu.findItem(R.id.action_notifications);
View actionView = item.getActionView();
ImageButton btnNotifications = actionView.findViewById(R.id.btnNotifications);
textBadge = actionView.findViewById(R.id.textBadge);
btnNotifications.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// Apri schermata notifiche
}
});
aggiornaBadge(5); // Esempio: 5 notifiche
return true;
}
private void aggiornaBadge(int count) {
if (textBadge == null) return;
if (count > 0) {
textBadge.setText(String.valueOf(count));
textBadge.setVisibility(View.VISIBLE);
} else {
textBadge.setVisibility(View.GONE);
}
}In questo modo il badge può essere aggiornato in qualsiasi momento (ad esempio dopo una chiamata API) richiamando aggiornaBadge(count), mantenendo la Toolbar sempre coerente con lo stato delle notifiche.
FAQ sulla Toolbar Android
1. Come nascondere la Toolbar in certe Activity?
Se stai usando la Toolbar come ActionBar tramite setSupportActionBar(toolbar), in un’activity specifica puoi nasconderla in vari modi, a seconda del caso d’uso:
- Nascondere solo in runtime (es. per una schermata full screen temporanea):
getSupportActionBar().hide();oppuregetSupportActionBar().show();per riattivarla. - Nascondere per tutta l’Activity (layout senza Toolbar): basta non includere la Toolbar nell’XML di quella activity e non chiamare
setSupportActionBar()nel relativo Java. - Nascondere su scroll: usa
AppBarLayoutconlayout_scrollFlags="scroll|enterAlways"per far scomparire la Toolbar quando si scorre verso il basso.
2. Come aggiungere un custom font al titolo della Toolbar?
Ci sono due approcci principali: usare un tema con font personalizzato oppure impostare una TextView personalizzata come titolo.
- Via tema (consigliato con Material Components): definisci il font in
res/font, poi nel tema impostafontFamilypertoolbarStyleo direttamente suTextAppearance.Widget.AppCompat.Toolbar.Title. - Via layout personalizzato: crea un file XML con una
TextViewche usa il font custom e poi nel codice:getSupportActionBar().setDisplayShowTitleEnabled(false);getSupportActionBar().setCustomView(R.layout.toolbar_title_layout);getSupportActionBar().setDisplayShowCustomEnabled(true);
3. Come fare la Toolbar trasparente?
Per ottenere una Toolbar trasparente (ad esempio sopra un’immagine di sfondo a schermo intero) puoi:
- Impostare lo sfondo trasparente in XML:
android:background="@android:color/transparent". - Rimuovere l’elevazione (ombra) se non desiderata:
android:elevation="0dp"oppure via Javatoolbar.setElevation(0f);. - Se vuoi che il contenuto vada sotto la status bar, usa
fitsSystemWindows="true"e un tema full screen/edge-to-edge.
4. Come gestire il back button nella Toolbar?
Per mostrare e gestire il pulsante back (freccia) nella Toolbar usata come ActionBar:
Toolbar toolbar = findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
if (getSupportActionBar() != null) {
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
if (item.getItemId() == android.R.id.home) {
onBackPressed();
return true;
}
return super.onOptionsItemSelected(item);
}In questo modo l’icona di navigazione viene gestita in maniera uniforme in tutte le Activity che mostrano la Toolbar con il tasto indietro.
5. Differenza tra Toolbar Android e ActionBar: quale usare?
La differenza principale è che la Toolbar è un normale ViewGroup inseribile ovunque nel layout, mentre la ActionBar è una parte fissa della finestra gestita dal framework.
- Toolbar: altamente personalizzabile (posizione, aspetto, animazioni), supporta layout complessi, può essere multipla nella stessa schermata, funziona bene con
CoordinatorLayoute componenti Material. - ActionBar: più rigida e meno flessibile, vincolata alla parte superiore della finestra; oggi è considerata legacy rispetto all’uso della Toolbar tramite AppCompat.
8. Articoli correlati
Per approfondire altri componenti fondamentali di Android Studio ti possono essere utili, inoltre, queste guide:
- Toast Android Studio – mostrare messaggi brevi all’utente
- AlertDialog Android in Android Studio – finestre di dialogo personalizzate
- Context Menu Android in Android Studio – menu contestuali su view
Combinando questi elementi con questi componenti potrai costruire interfacce complete e intuitive anche nei tuoi primi progetti Android Studio. Infine, questo approccio ti aiuta a mantenere coerenza e semplicità nel design.
Rispondi