Scopri come creare un Context Menu Android in Android Studio. Segui questa guida passo passo per configurare tutto correttamente. Troverai il codice XML e Java necessario. Il menu appare con un tocco prolungato sull’elemento e rende l’app più rapida, professionale e facile da usare.

Cos’è un Context Menu Android?

I Context Menu appaiono quando si mantiene il tocco per qualche istante sull’oggetto scelto. Rendono disponibili opzioni aggiuntive sempre a portata di mano. Permettono di selezionare più elementi e avviare azioni rapide. Migliorano produttività ed esperienza d’uso, rendendo l’interazione complessiva molto più fluida.

A differenza dei comandi nella barra degli strumenti, il context menu Android Studio è legato a un elemento specifico. Offre azioni pertinenti solo a quell’elemento. Mostra esclusivamente comandi utili in quel contesto, senza distrarre l’utente. È molto utile in liste e griglie, dove si selezionano più oggetti. Riduce i comandi visibili nella barra principale e mantiene l’interfaccia pulita e ordinata.

Passo 1 – Layout XML per il Context Menu Android

Context Menu “floating” vs Context Action Mode (CAB)

Su Android esistono due modi principali per mostrare azioni contestuali: il Context Menu floating (quello classico a comparsa) e il Context Action Mode (anche chiamato Contextual Action Bar o CAB). Entrambi reagiscono a un tocco prolungato, ma l’esperienza utente e l’implementazione sono diverse.

Context Menu floating:

• Mostra un piccolo menu che “galleggia” vicino alla view.
• Non modifica la barra superiore dell’app.
• È ideale per poche azioni mirate su un singolo elemento.

Context Action Mode (CAB):

• Sostituisce temporaneamente la Toolbar/ActionBar con una barra di azioni contestuali.
• Supporta selezione multipla in modo naturale (tipico nelle liste).
• Mostra titoli, icone e pulsanti specifici per la selezione corrente.

Esempio completo di Context Menu floating (Java)

public class MainActivity extends Activity {

    private TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        textView = findViewById(R.id.textView);

        // 1. Registriamo la view per il context menu floating
        registerForContextMenu(textView);
    }

    // 2. Creazione del menu contestuale floating
    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.context, menu);
    }

    // 3. Gestione della voce selezionata
    @Override
    public boolean onContextItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.MENU_1:
                Toast.makeText(this, "Hai toccato MENU_1", Toast.LENGTH_SHORT).show();
                return true;
            case R.id.MENU_2:
                Toast.makeText(this, "Hai toccato MENU_2", Toast.LENGTH_SHORT).show();
                return true;
            default:
                return super.onContextItemSelected(item);
        }
    }
}

Esempio completo di Context Action Mode (CAB)

In questo esempio abilitiamo un Context Action Mode su un TextView. Un tocco prolungato avvia il CAB e mostra azioni nella barra superiore.

public class CabActivity extends AppCompatActivity {

    private TextView textView;
    private ActionMode actionMode;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        textView = findViewById(R.id.textView);

        textView.setOnLongClickListener(v -> {
            if (actionMode != null) {
                return false;
            }
            // Avvia il Context Action Mode
            actionMode = startSupportActionMode(actionModeCallback);
            v.setSelected(true);
            return true;
        });
    }

    private final ActionMode.Callback actionModeCallback = new ActionMode.Callback() {
        @Override
        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
            // Gonfia il menu contestuale nella CAB
            mode.getMenuInflater().inflate(R.menu.cab_menu, menu);
            mode.setTitle("Azioni");
            return true;
        }

        @Override
        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
            // Aggiorna dinamicamente il menu se serve
            return false;
        }

        @Override
        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
            switch (item.getItemId()) {
                case R.id.action_share:
                    Toast.makeText(CabActivity.this, "Condividi", Toast.LENGTH_SHORT).show();
                    mode.finish(); // Chiude il CAB
                    return true;
                case R.id.action_delete:
                    Toast.makeText(CabActivity.this, "Elimina", Toast.LENGTH_SHORT).show();
                    mode.finish();
                    return true;
                default:
                    return false;
            }
        }

        @Override
        public void onDestroyActionMode(ActionMode mode) {
            actionMode = null;
            textView.setSelected(false);
        }
    };
}

Registrare una View con registerForContextMenu() in Android Studio

Perché il Context Menu compaia su una certa view, devi registrarla chiamando registerForContextMenu(). Questo metodo collega la view al ciclo di vita del menu contestuale, in modo che Android sappia quando mostrare il menu alla pressione prolungata.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    TextView textView = findViewById(R.id.textView);
    Button button = findViewById(R.id.button);

    // Entrambe le view avranno il proprio Context Menu
    registerForContextMenu(textView);
    registerForContextMenu(button);
}

Se chiami registerForContextMenu(view) su più view, il metodo onCreateContextMenu() verrà invocato per ognuna di esse. Nel metodo potrai distinguere l’origine del menu verificando il parametro View v.

onCreateContextMenu() e onContextItemSelected() nel Context Menu Android

I due metodi chiave per gestire il menu contestuale floating sono:

• onCreateContextMenu(): crea e popola il menu quando l’utente effettua il long-press.
• onContextItemSelected(): reagisce alla voce scelta e avvia l’azione corrispondente.

@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
    super.onCreateContextMenu(menu, v, menuInfo);

    // Titolo opzionale del menu
    menu.setHeaderTitle("Azioni rapide");

    // Gonfiamo da XML
    getMenuInflater().inflate(R.menu.context, menu);

    // Oppure aggiungiamo dinamicamente
    menu.add(0, 100, 0, "Voce dinamica");
}

@Override
public boolean onContextItemSelected(MenuItem item) {
    int id = item.getItemId();

    switch (id) {
        case R.id.MENU_1:
            // Azione per MENU_1
            Toast.makeText(this, "MENU_1 selezionato", Toast.LENGTH_SHORT).show();
            return true;
        case 100:
            // Voce aggiunta a runtime
            Toast.makeText(this, "Voce dinamica selezionata", Toast.LENGTH_SHORT).show();
            return true;
        default:
            return super.onContextItemSelected(item);
    }
}

Context Menu Android Studio su item di RecyclerView con OnLongClickListener

Su un elenco gestito da RecyclerView puoi mostrare un Context Menu quando l’utente tiene premuto su un singolo item. Il pattern più semplice è usare un OnLongClickListener in onBindViewHolder() o nel costruttore del ViewHolder.

public class MyAdapter extends RecyclerView.Adapter<MyAdapter.MyViewHolder> {

    private final List<String> items;

    public MyAdapter(List<String> items) {
        this.items = items;
    }

    @NonNull
    @Override
    public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.row_item, parent, false);
        return new MyViewHolder(view);
    }

    @Override
    public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
        String text = items.get(position);
        holder.textView.setText(text);

        holder.itemView.setOnLongClickListener(v -> {
            // Memorizza la posizione, se necessario
            v.showContextMenu(); // Mostra il context menu associato alla view
            return true;
        });
    }

    @Override
    public int getItemCount() {
        return items.size();
    }

    static class MyViewHolder extends RecyclerView.ViewHolder implements View.OnCreateContextMenuListener {

        TextView textView;

        MyViewHolder(@NonNull View itemView) {
            super(itemView);
            textView = itemView.findViewById(R.id.textView);

            // Colleghiamo il listener di creazione del menu alla root dell'item
            itemView.setOnCreateContextMenuListener(this);
        }

        @Override
        public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
            menu.setHeaderTitle("Azioni sull'elemento");
            menu.add(getAdapterPosition(), R.id.menu_edit, 0, "Modifica");
            menu.add(getAdapterPosition(), R.id.menu_delete, 1, "Elimina");
        }
    }
}

Nel Fragment o nell’Activity che ospita la RecyclerView, gestisci la selezione delle voci leggendo il groupId del MenuItem, che corrisponde alla posizione dell’item:

@Override
public boolean onContextItemSelected(MenuItem item) {
    int position = item.getGroupId(); // posizione dell'elemento nella lista

    switch (item.getItemId()) {
        case R.id.menu_edit:
            editItem(position);
            return true;
        case R.id.menu_delete:
            deleteItem(position);
            return true;
        default:
            return super.onContextItemSelected(item);
    }
}

Context Action Mode per selezione multipla (ActionMode.Callback)

Per gestire una selezione multipla in una lista (ad esempio una RecyclerView) il pattern consigliato è usare il Context Action Mode. Di solito si mantiene nello stato dell’adapter un flag per indicare se siamo in modalità di selezione e una collezione di elementi selezionati.

public class MultiSelectActivity extends AppCompatActivity implements ActionMode.Callback {

    private RecyclerView recyclerView;
    private MultiSelectAdapter adapter;
    private ActionMode actionMode;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_multi_select);

        recyclerView = findViewById(R.id.recyclerView);
        adapter = new MultiSelectAdapter(getItems(), this::onItemLongClicked, this::onItemClicked);
        recyclerView.setAdapter(adapter);
    }

    private boolean onItemLongClicked(int position) {
        if (actionMode == null) {
            actionMode = startSupportActionMode(this);
        }
        adapter.toggleSelection(position);
        updateCabTitle();
        return true;
    }

    private void onItemClicked(int position) {
        if (actionMode != null) {
            adapter.toggleSelection(position);
            if (adapter.getSelectedCount() == 0) {
                actionMode.finish();
            } else {
                updateCabTitle();
            }
        } else {
            // click normale, fuori dalla selezione multipla
        }
    }

    private void updateCabTitle() {
        int count = adapter.getSelectedCount();
        if (actionMode != null) {
            actionMode.setTitle(count + " selezionati");
        }
    }

    // ActionMode.Callback
    @Override
    public boolean onCreateActionMode(ActionMode mode, Menu menu) {
        mode.getMenuInflater().inflate(R.menu.multi_select_menu, menu);
        return true;
    }

    @Override
    public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
        return false;
    }

    @Override
    public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
        switch (item.getItemId()) {
            case R.id.action_delete:
                adapter.deleteSelected();
                mode.finish();
                return true;
            case R.id.action_share:
                adapter.shareSelected();
                mode.finish();
                return true;
            default:
                return false;
        }
    }

    @Override
    public void onDestroyActionMode(ActionMode mode) {
        adapter.clearSelection();
        actionMode = null;
    }
}

All’interno dell’adapter gestisci una struttura dati (ad esempio un Set<Integer>) con le posizioni selezionate e aggiorni la UI (colore di sfondo, icone, ecc.) nel metodo onBindViewHolder() in base allo stato di selezione.

Icone e sottomenu nel Context Menu Android Studio

Nel file XML del menu contestuale puoi definire icone e sottomenu per organizzare meglio le azioni. Non tutte le versioni di Android mostrano automaticamente le icone nei context menu, ma è buona pratica comunque impostarle.

<menu xmlns:android="http://schemas.android.com/apk/res/android">

    <item
        android:id="@+id/MENU_1"
        android:title="Condividi"
        android:icon="@drawable/ic_share" />

    <item
        android:id="@+id/MENU_2"
        android:title="Altro">

        <menu>
            <item
                android:id="@+id/MENU_2_SUB_1"
                android:title="Dettagli"
                android:icon="@drawable/ic_info" />

            <item
                android:id="@+id/MENU_2_SUB_2"
                android:title="Duplica"
                android:icon="@drawable/ic_copy" />
        </menu>
    </item>

</menu>

In onContextItemSelected() gestisci le voci del sottomenu come normali item, utilizzando i rispettivi id. I sottomenu sono utili quando hai molte opzioni ma vuoi mantenere il menu principale più compatto.

Passo 1 – Layout XML per il Context Menu Android

Crea il layout principale con un TextView su cui registrare il Context Menu. Avrai subito un elemento chiaro per testare il menu contestuale. Potrai riutilizzare la stessa struttura in altri progetti. Mantieni così coerente l’organizzazione del codice tra le diverse app.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:id="@+id/linearLayout"
    android:gravity="center">

    <TextView
        android:text="@string/hello_world"
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</LinearLayout>

Il LinearLayout è il contenitore principale con android:gravity="center", che centra il contenuto e garantisce una disposizione pulita degli elementi. Facilita anche la lettura sullo schermo. Il TextView con id @+id/textView è l’elemento su cui registriamo e visualizziamo il context menu Android Studio. Così verifichi subito il funzionamento del menu con un tocco prolungato. Puoi anche correggere rapidamente eventuali anomalie.

Passo 2 – File XML del menu contestuale Android

Crea il file context.xml nella cartella res/menu. Qui definisci in modo strutturato tutte le voci del menu contestuale. Potrai modificarle o ampliarle con facilità in seguito. Questo è utile quando aggiungi nuove funzionalità alla tua applicazione.

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/MENU_1" android:title="Data e Ora"/>
    <item android:id="@+id/MENU_2" android:title="Accessibilita'"/>
    <item android:id="@+id/MENU_3" android:title="Account"/>
    <item android:id="@+id/MENU_4" android:title="Connessione"/>
    <item android:id="@+id/MENU_5" android:title="Apn"/>
    <item android:id="@+id/MENU_6" android:title="Batteria"/>
    <item android:id="@+id/MENU_7" android:title="Informazioni"/>
    <item android:id="@+id/MENU_8" android:title="Cerca"/>
</menu>

Passo 3 – Implementare il context menu Android Studio in Java

Nel file MainActivity.java registriamo il Context Menu sulla TextView. Gestiamo le selezioni dell’utente con onContextItemSelected(). Qui colleghiamo le voci definite nel file XML alle azioni eseguite dall’app. Così il menu diventa davvero operativo all’interno dell’app.

package com.mycompany.myapp2;

import android.app.*;
import android.os.*;
import android.view.*;
import android.content.*;
import android.provider.*;
import android.widget.*;
import android.view.ContextMenu.*;

public class MainActivity extends Activity {

    TextView textView;
    LinearLayout linearLayout;

    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.context, menu);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        textView = findViewById(R.id.textView);
        linearLayout = findViewById(R.id.linearLayout);
        registerForContextMenu(textView);
    }

    @Override
    public boolean onContextItemSelected(MenuItem item) {
        int id = item.getItemId();
        switch (id) {
            case R.id.MENU_1:
                startActivity(new Intent(Settings.ACTION_DATE_SETTINGS));
                return true;
            case R.id.MENU_2:
                startActivity(new Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS));
                return true;
            case R.id.MENU_3:
                startActivity(new Intent(Settings.ACTION_ADD_ACCOUNT));
                return true;
            case R.id.MENU_4:
                startActivity(new Intent(Settings.ACTION_AIRPLANE_MODE_SETTINGS));
                return true;
            case R.id.MENU_5:
                startActivity(new Intent(Settings.ACTION_APN_SETTINGS));
                return true;
            case R.id.MENU_6:
                startActivity(new Intent(Settings.ACTION_BATTERY_SAVER_SETTINGS));
                return true;
            case R.id.MENU_7:
                startActivity(new Intent(Settings.ACTION_APPLICATION_SETTINGS));
                return true;
            case R.id.MENU_8:
                startActivity(new Intent(Settings.ACTION_APP_SEARCH_SETTINGS));
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }
}

Conclusione: Context Menu Android implementato

I metodi principali da implementare sono tre. onCreateContextMenu() gonfia il menu dal file XML. onCreate() chiama registerForContextMenu(view) e registra la view. onContextItemSelected() gestisce il click su ogni voce del menu contestuale. Questi tre punti costituiscono l’ossatura logica della funzionalità. Il flusso del Context Menu risulta così correttamente configurato. Ogni passaggio tra layout, menu e risposta all’utente è chiaro e ordinato. Il codice resta semplice da leggere e mantenere.

Per approfondire, consulta la documentazione ufficiale di ContextMenu su Android Developers. È la fonte più completa e aggiornata su funzionalità e metodi. Per la gestione delle impostazioni di sistema usate nell’esempio, vedi la classe Settings. Consulta anche la guida su Android Studio. Così integri in modo coerente gli elementi mostrati nel tutorial e ottieni un quadro generale più solido.

In questa guida hai visto come creare un Context Menu Android in Android Studio. Hai definito il layout, il file XML del menu e il codice Java. Hai verificato il comportamento finale sull’emulatore o sul dispositivo reale. Con un tocco prolungato sull’elemento registrato appare il menu contestuale con le opzioni definite nel file XML. L’utente accede rapidamente alle azioni più utili senza affollare la barra degli strumenti principale. L’interfaccia risulta più ordinata e centrata sui contenuti.

Domande frequenti sul Context Menu Android

1. Quando usare il Context Menu floating e quando il Context Action Mode?

Usa il Context Menu floating quando vuoi mostrare poche azioni rapide legate a un singolo elemento (ad esempio “Modifica” o “Dettagli” su una card). Usa il Context Action Mode quando devi gestire selezioni multiple o operazioni più complesse su gruppi di elementi (ad esempio selezionare più email e poi eliminarle, archiviarle, ecc.). In una stessa app puoi anche combinare i due approcci in parti diverse dell’interfaccia.

2. Devo sempre usare un file XML per definire il Context Menu?

No, puoi creare il menu anche dinamicamente in Java/Kotlin usando i metodi menu.add(), menu.addSubMenu() e simili. Tuttavia, definire il menu in XML (come res/menu/context.xml) rende il codice più leggibile, facilita la manutenzione e ti consente di riutilizzare la stessa struttura in più punti dell’app.

3. Perché il mio Context Menu non compare al long-press?

Le cause più comuni sono:

• Ti sei dimenticato di chiamare registerForContextMenu(view) nella tua Activity o Fragment.
• La view intercetta l’evento di long-press con un altro listener (ad esempio un OnLongClickListener che restituisce false in modo scorretto).
• La view non è effettivamente cliccabile/visibile o è coperta da un altro elemento.

4. Come gestisco le voci di Context Menu in un Fragment?

In un Fragment la logica è molto simile a quella di un’Activity. Devi:

• Chiamare registerForContextMenu(view) nel onViewCreated() del Fragment.
• Fare override di onCreateContextMenu() e onContextItemSelected() all’interno del Fragment.
• Se l’Activity e il Fragment gestiscono menu simili, assicurati di chiamare il super per non perdere gli eventi.

5. Posso usare le stesse azioni sia nel Context Menu sia nella Toolbar principale?

Sì. Spesso definisci le stesse azioni in più menu (Toolbar, Context Menu, CAB). Un approccio pulito è spostare la logica delle operazioni in metodi riutilizzabili (ad esempio deleteItem(), shareItem()) e chiamarli sia da onOptionsItemSelected() sia da onContextItemSelected() o da onActionItemClicked() dell’ActionMode. Così eviti duplicazione di codice e mantieni un comportamento coerente in tutta l’app.

6. Il Context Menu è ancora consigliato nelle app moderne?

Sì, se usato con moderazione. Nelle app moderne viene spesso affiancato da bottom sheet, popup menu e gesture. Tuttavia il Context Menu rimane utile per operazioni rapide su elementi di lista o per funzioni meno frequenti che non meritano un pulsante permanente nella UI. L’importante è mantenere i menu chiari, brevi e coerenti con il resto dell’esperienza utente.