Crea un'interfaccia di ricerca

Prova Compose

Jetpack Compose è il toolkit per la UI consigliato per Android. Scopri come aggiungere la funzionalità di ricerca in Scrivi.

Barra di ricerca →

Quando sei pronto per aggiungere la funzionalità di ricerca alla tua app, Android ti aiuta a implementare l'interfaccia utente con una finestra di dialogo di ricerca che viene visualizzata nella parte superiore della finestra dell'attività o con un widget di ricerca che puoi inserire nel layout. Sia la finestra di dialogo di ricerca sia il widget possono inviare la query di ricerca dell'utente a un'attività specifica della tua app. In questo modo, l'utente può avviare una ricerca da qualsiasi attività in cui è disponibile la finestra di dialogo di ricerca o il widget e il sistema avvia l'attività appropriata per eseguire la ricerca e presentare i risultati.

Altre funzionalità disponibili per la finestra di dialogo e il widget di ricerca includono:

• Ricerca vocale
• Suggerimenti di ricerca basati sulle query recenti
• Suggerimenti di ricerca che corrispondono ai risultati effettivi nei dati delle app

Questo documento mostra come configurare l'app per fornire un'interfaccia di ricerca assistita dal sistema Android per inviare query di ricerca, utilizzando la finestra di dialogo di ricerca o il widget di ricerca.

Risorse correlate:

• Icone Material Design

Nozioni di base

Prima di iniziare, decidi se implementare l'interfaccia di ricerca utilizzando la finestra di dialogo di ricerca o il widget di ricerca. Offrono le stesse funzionalità di ricerca, ma in modi leggermente diversi:

• La finestra di dialogo di ricerca è un componente UI controllato dal sistema Android. Quando viene attivata dall'utente, la finestra di dialogo di ricerca viene visualizzata nella parte superiore dell'attività.

  Il sistema Android controlla tutti gli eventi nella finestra di dialogo di ricerca. Quando l'utente invia una query, il sistema la invia all'attività che specifichi per gestire le ricerche. La finestra di dialogo può anche fornire suggerimenti di ricerca mentre l'utente digita.

• Il widget di ricerca è un'istanza di SearchView che puoi posizionare ovunque nel layout. Per impostazione predefinita, il widget di ricerca si comporta come un widget EditText standard e non esegue alcuna azione, ma puoi configurarlo in modo che il sistema Android gestisca tutti gli eventi di input, invii le query all'attività appropriata e fornisca suggerimenti di ricerca, proprio come la finestra di dialogo di ricerca.

Quando l'utente esegue una ricerca dalla finestra di dialogo di ricerca o da un widget di ricerca, il sistema crea un Intent e memorizza la query dell'utente. Il sistema avvia quindi l'attività che dichiari di gestire le ricerche, ovvero l'"attività ricercabile", e le trasmette l'intent. Per configurare l'app per questo tipo di ricerca assistita, devi disporre di quanto segue:

Una configurazione di ricerca

Un file XML che configura alcune impostazioni per la finestra di dialogo o il widget di ricerca. Include le impostazioni per funzionalità come la ricerca vocale, i suggerimenti di ricerca e il testo del suggerimento per la casella di ricerca.

Un'attività in cui è possibile eseguire ricerche

Il Activity che riceve la query di ricerca, esegue ricerche nei tuoi dati e mostra i risultati della ricerca.

Un'interfaccia di ricerca fornita da uno dei seguenti elementi:

La finestra di dialogo di ricerca

Per impostazione predefinita, la finestra di dialogo di ricerca è nascosta. Viene visualizzato nella parte superiore dello schermo quando chiami onSearchRequested() quando l'utente tocca il pulsante Cerca.

Un widget SearchView

L'utilizzo del widget di ricerca ti consente di inserire la casella di ricerca in qualsiasi punto della tua attività, anche come visualizzazione dell'azione nella barra delle app.

Il resto di questo documento mostra come creare la configurazione di ricerca e l'attività ricercabile e come implementare un'interfaccia di ricerca con la finestra di dialogo di ricerca o il widget di ricerca.

Creare una configurazione ricercabile

La prima cosa che ti serve è un file XML chiamato configurazione di ricerca. Configura alcuni aspetti dell'interfaccia utente della finestra di dialogo o del widget di ricerca e definisce il comportamento di funzionalità come suggerimenti e ricerca vocale. Questo file viene tradizionalmente chiamato searchable.xml e deve essere salvato nella directory del progetto res/xml/.

Il file di configurazione della ricerca deve includere l'elemento <searchable> come nodo radice e specificare uno o più attributi, come mostrato nell'esempio seguente:

<?xml version="1.0" encoding="utf-8"?>
<searchable xmlns:android="http://schemas.android.com/apk/res/android"
    android:label="@string/app_label"
    android:hint="@string/search_hint" >
</searchable>

L'attributo android:label è l'unico obbligatorio. Punta a una risorsa stringa, che deve essere il nome dell'app. Questa etichetta non è visibile all'utente finché non attivi i suggerimenti di ricerca per la casella di ricerca rapida, a quel punto l'etichetta è visibile nell'elenco degli elementi ricercabili nelle impostazioni di sistema.

Sebbene non sia obbligatorio, ti consigliamo di includere sempre l'attributo android:hint, che fornisce una stringa di suggerimento nella casella di ricerca prima che gli utenti inseriscano una query. Il suggerimento è importante perché fornisce indizi importanti agli utenti su cosa possono cercare.

L'elemento <searchable> accetta diversi altri attributi. Tuttavia, non hai bisogno della maggior parte degli attributi finché non aggiungi funzionalità come i suggerimenti di ricerca e la ricerca vocale. Per informazioni dettagliate sul file di configurazione della ricerca, consulta il documento di riferimento Configurazione della ricerca.

Creare un'attività ricercabile

Un'attività ricercabile è l'Activity nella tua app che esegue ricerche in base a una stringa di query e presenta i risultati di ricerca.

Quando l'utente esegue una ricerca nella finestra di dialogo o nel widget di ricerca, il sistema avvia l'attività di ricerca e invia la query di ricerca in un Intent con l'intent ACTION_SEARCH. La tua attività ricercabile recupera la query dall'extra QUERY dell'intent, quindi esegue la ricerca nei tuoi dati e presenta i risultati.

Poiché puoi includere la finestra di dialogo o il widget di ricerca in qualsiasi altra attività della tua app, il sistema deve sapere qual è l'attività ricercabile in modo da poter fornire correttamente la query di ricerca. Pertanto, dichiara prima l'attività in cui è possibile eseguire ricerche nel file manifest di Android.

Dichiarare un'attività ricercabile

Se non ne hai già uno, crea un Activity che esegua ricerche e presenti i risultati. Non devi ancora implementare la funzionalità di ricerca, ma devi creare un'attività che puoi dichiarare nel manifest. All'interno dell'elemento <activity> del manifest, segui questi passaggi:

1. Dichiara l'attività per accettare l'intent ACTION_SEARCH in un elemento <intent-filter>.
2. Specifica la configurazione di ricerca da utilizzare in un elemento <meta-data>.

Ciò è mostrato nel seguente esempio:

<application ... >
    <activity android:name=".SearchableActivity" >
        <intent-filter>
            <action android:name="android.intent.action.SEARCH" />
        </intent-filter>
        <meta-data android:name="android.app.searchable"
                   android:resource="@xml/searchable"/>
    </activity>
    ...
</application>

L'elemento <meta-data> deve includere l'attributo android:name con un valore di "android.app.searchable" e l'attributo android:resource con un riferimento al file di configurazione ricercabile. Nell'esempio precedente, si riferisce al file res/xml/searchable.xml.

Consente di effettuare una ricerca

Dopo aver dichiarato l'attività ricercabile nel manifest, segui questa procedura per eseguire una ricerca nell'attività ricercabile:

1. Ricevere la query.
2. Cerca nei tuoi dati.
3. Presenta i risultati.

Ricevere la query

Quando un utente esegue una ricerca dalla finestra di dialogo o dal widget di ricerca, il sistema avvia l'attività ricercabile e le invia un intent ACTION_SEARCH. Questo intent contiene la query di ricerca nell'extra della stringa QUERY. Controlla questo intent all'avvio dell'attività ed estrai la stringa. Ad esempio, ecco come ottenere la query di ricerca quando inizia la tua attività di ricerca:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.search)

    // Verify the action and get the query.
    if (Intent.ACTION_SEARCH == intent.action) {
        intent.getStringExtra(SearchManager.QUERY)?.also { query ->
            doMySearch(query)
        }
    }
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.search);

    // Get the intent, verify the action, and get the query.
    Intent intent = getIntent();
    if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
      String query = intent.getStringExtra(SearchManager.QUERY);
      doMySearch(query);
    }
}

La stringa QUERY è sempre inclusa nell'intent ACTION_SEARCH. Nell'esempio precedente, la query viene recuperata e passata a un metodo doMySearch() locale in cui viene eseguita l'operazione di ricerca effettiva.

Cercare i dati

Il processo di archiviazione e ricerca dei dati è specifico per la tua app. Puoi archiviare e cercare i dati in molti modi e questo documento non ti mostra come. Valuta come archiviare e cercare i dati in base alle tue esigenze e al formato dei dati. Di seguito sono riportati alcuni suggerimenti che potresti riuscire ad applicare:

• Se i tuoi dati sono memorizzati in un database SQLite sul dispositivo, l'esecuzione di una ricerca full-text, utilizzando FTS3 anziché una query LIKE, può fornire una ricerca più solida nei dati di testo e può produrre risultati molto più velocemente. Consulta sqlite.org per informazioni su FTS3 e sulla classe SQLiteDatabase per informazioni su SQLite su Android.
• Se i tuoi dati sono archiviati online, le prestazioni di ricerca percepite potrebbero essere limitate dalla connessione dati dell'utente. Ti consigliamo di visualizzare un indicatore di avanzamento finché la ricerca non restituisce risultati. Consulta android.net per un riferimento alle API di rete e ProgressBar per informazioni su come visualizzare un indicatore di avanzamento.

Presentare i risultati

Indipendentemente da dove si trovano i tuoi dati e da come li cerchi, ti consigliamo di restituire i risultati di ricerca alla tua attività ricercabile con un Adapter. In questo modo, puoi presentare tutti i risultati di ricerca in un RecyclerView. Se i tuoi dati provengono da una query del database SQLite, puoi applicare i risultati a un RecyclerView utilizzando un CursorAdapter. Se i tuoi dati sono in un formato diverso, puoi creare un'estensione di BaseAdapter.

Un Adapter associa ogni elemento di un set di dati a un oggetto View. Quando il Adapter viene applicato a un RecyclerView, ogni dato viene inserito come visualizzazione individuale nell'elenco. Adapter è solo un'interfaccia, quindi sono necessarie implementazioni come CursorAdapter, per il binding dei dati da un Cursor. Se nessuna delle implementazioni esistenti funziona per i tuoi dati, puoi implementarne una personalizzata da BaseAdapter.

Utilizzare la finestra di dialogo di ricerca

La finestra di dialogo di ricerca fornisce una casella di ricerca mobile nella parte superiore dello schermo, con l'icona dell'app a sinistra. La finestra di dialogo di ricerca può fornire suggerimenti di ricerca mentre l'utente digita. Quando l'utente esegue una ricerca, il sistema invia la query di ricerca a un'attività ricercabile che esegue la ricerca.

Per impostazione predefinita, la finestra di dialogo di ricerca è sempre nascosta finché l'utente non la attiva. La tua app può attivare la finestra di dialogo di ricerca chiamando onSearchRequested(). Tuttavia, questo metodo non funziona finché non attivi la finestra di dialogo di ricerca per l'attività.

Per consentire alla finestra di dialogo di ricerca di eseguire le ricerche, indica al sistema quale attività ricercabile deve ricevere le query di ricerca dalla finestra di dialogo di ricerca. Ad esempio, nella sezione precedente sulla creazione di un'attività ricercabile, viene creata un'attività ricercabile denominata SearchableActivity. Se vuoi che un'attività separata, ad esempio una denominata OtherActivity, mostri la finestra di dialogo di ricerca e invii le ricerche a SearchableActivity, dichiara nel manifest che SearchableActivity è l'attività ricercabile da utilizzare per la finestra di dialogo di ricerca in OtherActivity.

Per dichiarare l'attività ricercabile per la finestra di dialogo di ricerca di un'attività, aggiungi un elemento <meta-data> all'interno dell'elemento <activity> dell'attività corrispondente. L'elemento <meta-data> deve includere l'attributo android:value che specifica il nome della classe dell'attività in cui è possibile eseguire ricerche e l'attributo android:name con un valore di "android.app.default_searchable".

Ad esempio, ecco la dichiarazione per un'attività ricercabile, SearchableActivity, e un'altra attività, OtherActivity, che utilizza SearchableActivity per eseguire le ricerche eseguite dalla relativa finestra di dialogo di ricerca:

<application ... >
    <!-- This is the searchable activity; it performs searches. -->
    <activity android:name=".SearchableActivity" >
        <intent-filter>
            <action android:name="android.intent.action.SEARCH" />
        </intent-filter>
        <meta-data android:name="android.app.searchable"
                   android:resource="@xml/searchable"/>
    </activity>

    <!-- This activity enables the search dialog to initiate searches
         in the SearchableActivity. -->
    <activity android:name=".OtherActivity" ... >
        <!-- Enable the search dialog to send searches to SearchableActivity. -->
        <meta-data android:name="android.app.default_searchable"
                   android:value=".SearchableActivity" />
    </activity>
    ...
</application>

Poiché OtherActivity ora include un elemento <meta-data> per dichiarare quale attività ricercabile utilizzare per le ricerche, l'attività attiva la finestra di dialogo di ricerca. Sebbene l'utente sia in questa attività, il metodo onSearchRequested() attiva la finestra di dialogo di ricerca. Quando l'utente esegue la ricerca, il sistema avvia SearchableActivity e gli invia l'intent ACTION_SEARCH.

Se vuoi che ogni attività della tua app fornisca la finestra di dialogo di ricerca, inserisci l'elemento <meta-data> precedente come elemento secondario dell'elemento <application> anziché di ogni <activity>. In questo modo, ogni attività eredita il valore, fornisce la finestra di dialogo di ricerca e invia le ricerche alla stessa attività ricercabile. Se hai più attività in cui è possibile eseguire ricerche, puoi ignorare l'attività in cui è possibile eseguire ricerche predefinita inserendo una dichiarazione <meta-data> diversa all'interno delle singole attività.

Ora che la finestra di dialogo di ricerca è abilitata per le tue attività, la tua app è pronta per eseguire le ricerche.

Richiamare la finestra di dialogo di ricerca

Sebbene alcuni dispositivi forniscano un pulsante di ricerca dedicato, il comportamento del pulsante potrebbe variare a seconda del dispositivo e molti dispositivi non forniscono affatto un pulsante di ricerca. Pertanto, quando utilizzi la finestra di dialogo di ricerca, devi fornire un pulsante di ricerca nella tua UI che attiva la finestra di dialogo di ricerca chiamando onSearchRequested().

Ad esempio, aggiungi un pulsante di ricerca nel tuo menu delle opzioni o nel layout dell'interfaccia utente che chiama onSearchRequested().

Puoi anche attivare la funzionalità "Digita per cercare", che attiva la finestra di dialogo di ricerca quando l'utente inizia a digitare sulla tastiera. Le sequenze di tasti vengono inserite nella finestra di dialogo per la ricerca. Puoi attivare la digitazione per la ricerca nella tua attività chiamando setDefaultKeyMode o DEFAULT_KEYS_SEARCH_LOCAL durante l'attività onCreate().

L'impatto della finestra di dialogo di ricerca sul ciclo di vita dell'attività

La finestra di dialogo di ricerca è un Dialog che fluttua nella parte superiore dello schermo. Non causa alcuna modifica nello stack di attività, quindi quando viene visualizzata la finestra di dialogo di ricerca, non vengono chiamati metodi del ciclo di vita, ad esempio onPause(). L'attività perde lo stato attivo perché viene assegnato alla finestra di dialogo di ricerca.

Se vuoi ricevere una notifica quando viene attivata la finestra di dialogo di ricerca, esegui l'override del metodo onSearchRequested(). Quando il sistema chiama questo metodo, significa che l'attività perde lo stato attivo dell'input nella finestra di dialogo di ricerca, quindi puoi eseguire qualsiasi operazione appropriata per l'evento, ad esempio mettere in pausa un gioco. A meno che non trasmetti dati sul contesto di ricerca, argomento trattato in un'altra sezione di questo documento, termina il metodo chiamando l'implementazione della superclasse:

override fun onSearchRequested(): Boolean {
    pauseSomeStuff()
    return super.onSearchRequested()
}

@Override
public boolean onSearchRequested() {
    pauseSomeStuff();
    return super.onSearchRequested();
}

Se l'utente annulla la ricerca toccando il pulsante Indietro, la finestra di dialogo di ricerca si chiude e l'attività riacquista lo stato attivo di input. Puoi registrarti per ricevere una notifica quando la finestra di dialogo di ricerca viene chiusa con setOnDismissListener(), setOnCancelListener() o entrambi. Devi registrare solo OnDismissListener, perché viene chiamato ogni volta che la finestra di dialogo di ricerca si chiude. OnCancelListener si riferisce solo agli eventi in cui l'utente esce esplicitamente dalla finestra di dialogo di ricerca, quindi non viene chiamato quando viene eseguita una ricerca. Quando viene eseguita la ricerca, la finestra di dialogo di ricerca scompare automaticamente.

Se l'attività corrente non è l'attività ricercabile, gli eventi del ciclo di vita dell'attività normale vengono attivati quando l'utente esegue una ricerca. L'attività corrente riceve onPause(), come descritto in Introduzione alle attività. Tuttavia, se l'attività corrente è l'attività ricercabile, si verifica una delle due situazioni seguenti:

• Per impostazione predefinita, l'attività ricercabile riceve l'intent ACTION_SEARCH con una chiamata a onCreate(), e una nuova istanza dell'attività viene portata in cima allo stack delle attività. Ora ci sono due istanze della tua attività ricercabile nello stack di attività, quindi toccando il pulsante Indietro si torna all'istanza precedente dell'attività ricercabile, anziché uscire dall'attività ricercabile.
• Se imposti android:launchMode su "singleTop", l'attività ricercabile riceve l'intent ACTION_SEARCH con una chiamata a onNewIntent(Intent), trasmettendo il nuovo intent ACTION_SEARCH. Ad esempio, ecco come potresti gestire questo caso, in cui la modalità di avvio dell'attività ricercabile è "singleTop":

  Kotlin

  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContentView(R.layout.search)
      handleIntent(intent)
  }
  
  override fun onNewIntent(intent: Intent) {
      super.onNewIntent(intent)
      setIntent(intent)
      handleIntent(intent)
  }
  
  private fun handleIntent(intent: Intent) {
      if (Intent.ACTION_SEARCH == intent.action) {
          intent.getStringExtra(SearchManager.QUERY)?.also { query ->
              doMySearch(query)
          }
      }
  }

  Java

  @Override
  public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.search);
      handleIntent(getIntent());
  }
  
  @Override
  protected void onNewIntent(Intent intent) {
      super.onNewIntent(intent);
      setIntent(intent);
      handleIntent(intent);
  }
  
  private void handleIntent(Intent intent) {
      if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
        String query = intent.getStringExtra(SearchManager.QUERY);
        doMySearch(query);
      }
  }

  Rispetto al codice di esempio nella sezione relativa all'esecuzione di una ricerca, tutto il codice per gestire l'intent di ricerca si trova ora nel metodo handleIntent(), in modo che possa essere eseguito sia da onCreate() sia da onNewIntent().

  Quando il sistema chiama onNewIntent(Intent), l'attività non viene riavviata, quindi il metodo getIntent() restituisce lo stesso intent ricevuto con onCreate(). Ecco perché devi chiamare setIntent(Intent) all'interno di onNewIntent(Intent): in modo che l'intent salvato dall'attività venga aggiornato nel caso in cui chiami getIntent() in futuro.

Il secondo scenario, che utilizza la modalità di avvio "singleTop", è in genere preferibile perché, dopo aver eseguito una ricerca, l'utente potrebbe eseguire ulteriori ricerche e non vuoi che la tua app crei più istanze dell'attività di ricerca. Ti consigliamo di impostare l'attività ricercabile sulla modalità di avvio "singleTop" nel manifest dell'app, come mostrato nell'esempio seguente:

<activity android:name=".SearchableActivity"
          android:launchMode="singleTop" >
    <intent-filter>
        <action android:name="android.intent.action.SEARCH" />
    </intent-filter>
    <meta-data
          android:name="android.app.searchable"
          android:resource="@xml/searchable"/>
  </activity>

Trasmettere i dati del contesto di ricerca

In alcuni casi, puoi apportare i perfezionamenti necessari alla query di ricerca all'interno dell'attività ricercabile per ogni ricerca effettuata. Tuttavia, se vuoi perfezionare i criteri di ricerca in base all'attività da cui l'utente esegue una ricerca, puoi fornire dati aggiuntivi nell'intent che il sistema invia all'attività ricercabile. Puoi trasmettere i dati aggiuntivi in APP_DATA Bundle, che è incluso nell'intent ACTION_SEARCH.

Per trasmettere questo tipo di dati all'attività in cui è possibile eseguire ricerche, esegui l'override del metodo onSearchRequested() per l'attività da cui l'utente può eseguire una ricerca, crea un Bundle con i dati aggiuntivi e chiama startSearch() per attivare la finestra di dialogo di ricerca. Ad esempio:

override fun onSearchRequested(): Boolean {
    val appData = Bundle().apply {
        putBoolean(JARGON, true)
    }
    startSearch(null, false, appData, false)
    return true
}

@Override
public boolean onSearchRequested() {
     Bundle appData = new Bundle();
     appData.putBoolean(SearchableActivity.JARGON, true);
     startSearch(null, false, appData, false);
     return true;
 }

Il valore true indica che hai gestito correttamente questo evento di callback e chiama startSearch() per attivare la finestra di dialogo di ricerca. Dopo che l'utente invia una query, questa viene inviata alla tua attività ricercabile insieme ai dati che aggiungi. Puoi estrarre i dati aggiuntivi da APP_DATA Bundle per perfezionare la ricerca, come mostrato nell'esempio seguente:

val jargon: Boolean = intent.getBundleExtra(SearchManager.APP_DATA)?.getBoolean(JARGON) ?: false

Bundle appData = getIntent().getBundleExtra(SearchManager.APP_DATA);
if (appData != null) {
    boolean jargon = appData.getBoolean(SearchableActivity.JARGON);
}

Utilizzare il widget di ricerca

Figura 1. Il widget SearchView come visualizzazione dell'azione nella barra dell'app.

Il widget di ricerca offre le stesse funzionalità della finestra di dialogo di ricerca. Avvia l'attività appropriata quando l'utente esegue una ricerca e può fornire suggerimenti di ricerca ed eseguire la ricerca vocale. Se non puoi inserire il widget di ricerca nella barra delle app, puoi inserirlo in un altro punto del layout dell'attività.

Configurare il widget di ricerca

Dopo aver creato una configurazione di ricerca e un' attività ricercabile, attiva la ricerca assistita per ogni SearchView chiamando setSearchableInfo() e passando l'oggetto SearchableInfo che rappresenta la tua configurazione ricercabile.

Puoi ottenere un riferimento a SearchableInfo chiamando il numero getSearchableInfo() su SearchManager.

Ad esempio, se utilizzi un SearchView come visualizzazione dell'azione nella barra delle app, attiva il widget durante il callback onCreateOptionsMenu(), come mostrato nell'esempio seguente:

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    // Inflate the options menu from XML.
    val inflater = menuInflater
    inflater.inflate(R.menu.options_menu, menu)

    // Get the SearchView and set the searchable configuration.
    val searchManager = getSystemService(Context.SEARCH_SERVICE) as SearchManager
    (menu.findItem(R.id.menu_search).actionView as SearchView).apply {
        // Assumes current activity is the searchable activity.
        setSearchableInfo(searchManager.getSearchableInfo(componentName))
        setIconifiedByDefault(false) // Don't iconify the widget. Expand it by default.
    }

    return true
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the options menu from XML.
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.options_menu, menu);

    // Get the SearchView and set the searchable configuration.
    SearchManager searchManager = (SearchManager) getSystemService(Context.SEARCH_SERVICE);
    SearchView searchView = (SearchView) menu.findItem(R.id.menu_search).getActionView();
    // Assumes current activity is the searchable activity.
    searchView.setSearchableInfo(searchManager.getSearchableInfo(getComponentName()));
    searchView.setIconifiedByDefault(false); // Don't iconify the widget. Expand it by default.

    return true;
}

Il widget di ricerca è ora configurato e il sistema invia le query di ricerca alla tua attività ricercabile. Puoi anche attivare i suggerimenti di ricerca per il widget di ricerca.

Per saperne di più sulle visualizzazioni delle azioni nella barra delle app, vedi Utilizzare le visualizzazioni delle azioni e i provider di azioni.

Altre funzionalità del widget Ricerca

Il widget SearchView offre alcune funzionalità aggiuntive che potresti trovare utili:

Un pulsante Invia

Per impostazione predefinita, non è presente alcun pulsante per inviare una query di ricerca, quindi l'utente deve premere il tasto Invio sulla tastiera per avviare una ricerca. Puoi aggiungere un pulsante "Invia" chiamando setSubmitButtonEnabled(true).

Perfezionamento delle query per i suggerimenti di ricerca

Quando attivi i suggerimenti di ricerca, in genere ti aspetti che gli utenti selezionino un suggerimento, ma potrebbero anche voler perfezionare la query di ricerca suggerita. Puoi aggiungere un pulsante accanto a ogni suggerimento che inserisce il suggerimento nella casella di ricerca per la modifica da parte dell'utente chiamando setQueryRefinementEnabled(true).

Possibilità di attivare/disattivare la visibilità della casella di ricerca

Per impostazione predefinita, il widget di ricerca è "iconizzato", ovvero è rappresentato solo da un'icona di ricerca, una lente d'ingrandimento. Si espande per mostrare la casella di ricerca quando l'utente tocca l'icona. Come mostrato nell'esempio precedente, puoi mostrare la casella di ricerca per impostazione predefinita chiamando setIconifiedByDefault(false). Puoi anche attivare/disattivare la visualizzazione del widget di ricerca chiamando setIconified().

Nella classe SearchView sono presenti diverse altre API che consentono di personalizzare il widget di ricerca. Tuttavia, la maggior parte viene utilizzata solo quando gestisci personalmente tutti gli input dell'utente, anziché utilizzare il sistema Android per fornire query di ricerca e visualizzare suggerimenti di ricerca.

Utilizzare sia il widget che la finestra di dialogo

Se inserisci il widget di ricerca nella barra delle app come visualizzazione azione e lo abiliti in modo che venga visualizzato nella barra delle app se c'è spazio, impostando android:showAsAction="ifRoom", il widget di ricerca potrebbe non essere visualizzato come visualizzazione azione. Un elemento del menu potrebbe invece essere visualizzato nel menu di overflow. Ad esempio, quando la tua app viene eseguita su uno schermo più piccolo, potrebbe non esserci spazio sufficiente nella barra dell'app per visualizzare il widget di ricerca insieme ad altri elementi di azione o di navigazione, quindi la voce di menu viene visualizzata nel menu overflow. Se inserito nel menu extra, l'elemento funziona come una normale voce di menu e non visualizza la visualizzazione dell'azione, ovvero il widget di ricerca.

Per gestire questa situazione, la voce di menu a cui colleghi il widget di ricerca deve attivare la finestra di dialogo di ricerca quando l'utente la seleziona dal menu overflow. Per fare in modo che ciò accada, implementa onOptionsItemSelected() per gestire la voce di menu "Cerca" e aprire la finestra di dialogo di ricerca chiamando onSearchRequested().

Per saperne di più su come funzionano gli elementi nella barra delle app e su come gestire questa situazione, vedi Aggiungere la barra delle app.

Aggiungere la ricerca vocale

Puoi aggiungere la funzionalità di ricerca vocale alla finestra di dialogo o al widget di ricerca aggiungendo l'attributo android:voiceSearchMode alla configurazione di ricerca. Viene aggiunto un pulsante di ricerca vocale che avvia un prompt vocale. Quando l'utente finisce di parlare, la query di ricerca trascritta viene inviata alla tua attività ricercabile.

Ciò è mostrato nel seguente esempio:

<?xml version="1.0" encoding="utf-8"?>
<searchable xmlns:android="http://schemas.android.com/apk/res/android"
    android:label="@string/search_label"
    android:hint="@string/search_hint"
    android:voiceSearchMode="showVoiceSearchButton|launchRecognizer" >
</searchable>

Il valore showVoiceSearchButton è obbligatorio per attivare la ricerca vocale. Il secondo valore, launchRecognizer, specifica che il pulsante di ricerca vocale deve avviare un riconoscitore che restituisce il testo trascritto all'attività in cui è possibile eseguire ricerche.

Puoi fornire attributi aggiuntivi per specificare il comportamento della ricerca vocale, come la lingua prevista e il numero massimo di risultati da restituire. Per saperne di più sugli attributi disponibili, consulta il riferimento alla configurazione della ricerca.

Aggiungere suggerimenti di ricerca

Sia la finestra di dialogo di ricerca che il widget di ricerca possono fornire suggerimenti di ricerca man mano che l'utente digita, con l'assistenza del sistema Android. Il sistema gestisce l'elenco dei suggerimenti e gestisce l'evento quando l'utente seleziona un suggerimento.

Puoi fornire due tipi di suggerimenti di ricerca:

Suggerimenti di ricerca per query recenti

Questi suggerimenti sono parole che l'utente ha utilizzato in precedenza come query di ricerca nella tua app. Per ulteriori informazioni, consulta Aggiungere suggerimenti di ricerca personalizzati.

Suggerimenti di ricerca personalizzati

Si tratta di suggerimenti di ricerca che fornisci dalla tua origine dati per aiutare gli utenti a selezionare immediatamente l'ortografia o l'articolo corretti che stanno cercando. Per saperne di più, consulta Aggiungere suggerimenti di ricerca personalizzati.