Input vocale

L'input vocale consente di creare un'interfaccia veramente in vivavoce. Vetro ti offre tre modi per utilizzare l'input vocale.

I comandi vocali principali avviano Glassware dalla scheda Home, voce contestuale possono eseguire azioni all'interno di un'attività e la voce del sistema l'attività di riconoscimento ti consente di ricevere input vocali in formato libero dagli utenti.

Comandi vocali principali

Questi comandi vocali avviano Glassware dalla scheda Home (scheda Orologio). Quando dichiarare un comando vocale principale, Glass crea automaticamente una voce di menu touch come riserva se gli utenti decidono di iniziare a usare Glassware toccando Scheda Casa.

Per aggiungere un comando vocale al menu principale vocale di ok Glass:

1. Crea una risorsa XML per il comando vocale in res/xml/<my_voice_trigger>.xml che usa uno dei comandi vocali esistenti definiti in VoiceTriggers.Command Ad esempio, ecco come utilizzare "Inizia una corsa".

   Nota: puoi utilizzare i comandi vocali non in elenco per e per scopi di sviluppo.

   <?xml version="1.0" encoding="utf-8"?>
   <trigger command="START_A_RUN" />
   

   Per creare un comando vocale che richieda all'utente di pronunciare un altro comando una frase prima di iniziare l'attività o il servizio, includi un'istruzione input . Ad esempio, potresti voler eseguire questa operazione utilizzando l'opzione "Pubblica un aggiornamento".

   <?xml version="1.0" encoding="utf-8"?>
   <trigger command="POST_AN_UPDATE">
       <input prompt="@string/glass_voice_prompt" />
   </trigger>
   

2. Registra un filtro per intent utilizzando Azione com.google.android.glass.action.VOICE_TRIGGER in File manifest Android. Il filtro per intent avvia la tua attività o il tuo servizio se rileva che gli utenti pronunciano il tuo comando vocale.

   <?xml version="1.0" encoding="utf-8"?>
   <application ...>
       <activity | service ...>
           <intent-filter>
               <action android:name=
                       "com.google.android.glass.action.VOICE_TRIGGER" />
           </intent-filter>
           <meta-data android:name="com.google.android.glass.VoiceTrigger"
               android:resource="@xml/my_voice_trigger" />
       </activity | service>
       // ...
   </application>
   

3. Dichiara un attributo android:icon per la tua attività o il tuo servizio. In questo modo, Glass può visualizzare un'icona per Glassware nel Ok, vetro touch del menu.

   <activity |service
       android:icon="@drawable/my_icon" ...>
     ...
   </activity | service>
   

4. Se il comando vocale utilizza un prompt vocale e avvia un'attività, ottieni qualsiasi testo trascritto con il seguente codice (ad esempio, onResume()):

   ArrayList<String> voiceResults = getIntent().getExtras()
           .getStringArrayList(RecognizerIntent.EXTRA_RESULTS);
   

   Se il comando vocale avvia un servizio, l'intent extra è disponibile nella Chiamata di onStartCommand():

   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
       ArrayList<String> voiceResults = intent.getExtras()
               .getStringArrayList(RecognizerIntent.EXTRA_RESULTS);
       // ...
   }
   

Impostazione dei vincoli

Se ti occorre una o tutte le seguenti funzionalità per iniziare a utilizzare Glassware, e specificarli nella risorsa res/xml/<my_voice_trigger>.xml. Se le funzionalità non sono disponibili, Glass disattiva il comando vocale:

• camera
• network

• microphone

  <trigger command="POST_AN_UPDATE">
      <constraints
          camera="true"
          network="true" />
  </trigger>
  

Comandi vocali contestuali

I comandi vocali contestuali consentono agli utenti di eseguire azioni dalle attività. Crei comandi vocali contestuali con le API menu Android standard, gli utenti possono richiamare le voci di menu con i comandi vocali anziché con il tocco.

Per attivare i comandi vocali contestuali per una determinata attività:

1. Chiama il numero getWindow().requestFeature(WindowUtils.FEATURE_VOICE_COMMANDS) nell'attività desiderata per attivare i comandi vocali contestuali. Con questa funzione l'opzione "ok Glass" viene visualizzata nell'area del piè di pagina dello schermo. ogni volta che questa attività viene messa a fuoco.

2. Esegui l'override di onCreatePanelMenu() e gestire il caso in cui WindowUtils.FEATURE_VOICE_COMMANDS sia abilitato. Se questa opzione è attiva, qui puoi configurare il menu una tantum, ad esempio gonfiando una risorsa di menu o chiamando il Menu.add() per creare il tuo sistema di menu vocale.

3. Esegui l'override di onMenuItemSelected() per gestire i comandi vocali pronunciati dagli utenti. Quando gli utenti hanno finito Selezionando una voce di menu, il comando vocale "ok, vetro" automaticamente riappare nella sezione del piè di pagina dello schermo, quando è pronto ad accettare una nuova voce finché l'attività rimane attiva.

   Il seguente codice abilita comandi vocali contestuali e gonfia una risorsa del menu quando opportuno e gestisce i comandi vocali quando vengono pronunciati:

   public class ContextualMenuActivity extends Activity {
   
       @Override
       protected void onCreate(Bundle bundle) {
           super.onCreate(bundle);
   
           // Requests a voice menu on this activity. As for any other
           // window feature, be sure to request this before
           // setContentView() is called
           getWindow().requestFeature(WindowUtils.FEATURE_VOICE_COMMANDS);
           setContentView(R.layout.activity_main);
       }
   
       @Override
       public boolean onCreatePanelMenu(int featureId, Menu menu) {
           if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS) {
               getMenuInflater().inflate(R.menu.main, menu);
               return true;
           }
           // Pass through to super to setup touch menu.
           return super.onCreatePanelMenu(featureId, menu);
       }
   
       @Override
       public boolean onCreateOptionsMenu(Menu menu) {
           getMenuInflater().inflate(R.menu.main, menu);
           return true;
       }
   
       @Override
       public boolean onMenuItemSelected(int featureId, MenuItem item) {
           if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS) {
               switch (item.getItemId()) {
                   case R.id.dogs_menu_item:
                       // handle top-level dogs menu item
                       break;
                   case R.id.cats_menu_item:
                       // handle top-level cats menu item
                       break;
                   case R.id.lab_menu_item:
                       // handle second-level labrador menu item
                       break;
                   case R.id.golden_menu_item:
                       // handle second-level golden menu item
                       break;
                   case R.id.calico_menu_item:
                       // handle second-level calico menu item
                       break;
                   case R.id.cheshire_menu_item:
                       // handle second-level cheshire menu item
                       break;
                   default:
                       return true;
               }
               return true;
           }
           // Good practice to pass through to super if not handled
           return super.onMenuItemSelected(featureId, item);
       }
   }
   

   Ecco un esempio della risorsa di menu utilizzata dall'attività precedente. Nota come puoi creare voci di menu nidificate per avere una voce gerarchica del menu principale. Nell'esempio seguente, la prima voce di menu può Per accedervi è necessario usare: ok glass, Show me dogs, Labrador.

   <menu xmlns:android="http://schemas.android.com/apk/res/android">
       <!-- Use the constants defined in the ContextualMenus.Command enum-->
       <item
           android:id="@+id/dogs_menu_item"
           android:title="@string/show_me_dogs">
           <menu>
               <item
                   android:id="@+id/lab_menu_item"
                   android:title="@string/labrador" />
               <item
                   android:id="@+id/golden_menu_item"
                   android:title="@string/golden" />
           </menu>
       </item>
       <item
           android:id="@+id/cats_menu_item"
           android:title="@string/show_me_cats">
           <menu>
               <item
                   android:id="@+id/cheshire_menu_item"
                   android:title="@string/cheshire" />
               <item
                   android:id="@+id/calico_menu_item"
                   android:title="@string/calico" />
           </menu>
       </item>
   </menu>
   

   Nota: i titoli del menu nella risorsa di menu precedente utilizzano stringhe, cosa che puoi fare se specifichi l'autorizzazione per lo sviluppo. In Glassware, utilizza i valori nella sezione ContextualMenus.Command enum. Ad esempio, per utilizzare PLAY_MUSIC e PAUSE_MUSIC, puoi creare la seguente risorsa di menu:

   <menu xmlns:android="http://schemas.android.com/apk/res/android">
       <!-- Use the constants defined in the ContextualMenus.Command enum-->
       <item
           android:id="@+id/play_menu_item"
           android:title="PLAY_MUSIC" />
       <item
           android:id="@+id/pause_menu_item"
           android:title="PAUSE_MUSIC" />
   </menu>
   

4. (Facoltativo) Override onPreparePanel(), controllare se WindowUtils.FEATURE_VOICE_COMMANDS abilitata. Se attivata, qui puoi fare un'altra logica per configurare il menu del sistema, come l'aggiunta e la rimozione di determinate voci di menu in base ad alcuni criteri. Puoi anche attivare/disattivare i menu vocali contestuali (ritorno a true) (restituisce false) in base ad alcuni criteri. Ad esempio:

       private boolean mVoiceMenuEnabled;
       ...
       @Override
       public boolean onPreparePanel(int featureId, View view, Menu menu) {
           if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS) {
           // toggle this boolean on and off based on some criteria
               return mVoiceMenuEnabled;
           }
           // Good practice to call through to super for other cases
           return super.onPreparePanel(featureId, view, menu);
       }
   

Supporto simultaneo di menu vocali e touch

Poiché i comandi vocali contestuali utilizzano le API del menu Android esistenti, puoi riutilizzare gran parte del codice e delle risorse che già hai per i menu touch e supporta contemporaneamente entrambi i tipi di menu.

Devi solo controllare se è disponibile la funzionalità Window.FEATURE_OPTIONS_PANEL oltre alla funzionalità WindowUtils.FEATURE_VOICE_COMMANDS che hai già ci sono vari metodi, per poi aggiungere una logica per aprire menu su alcune azioni dell'utente, ad esempio un tocco.

Ad esempio, puoi modificare l'attività precedente esempio per aggiungere il supporto di menu touch come questo (le modifiche sono commenti):

// 1. Check for Window.FEATURE_OPTIONS_PANEL
// to inflate the same menu resource for touch menus.
@Override
public boolean onCreatePanelMenu(int featureId, Menu menu) {
    if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS ||
            featureId == Window.FEATURE_OPTIONS_PANEL) {
    ...
}

// 2. Check for Window.FEATURE_OPTIONS_PANEL
// to handle touch menu item selections.
@Override
public boolean onMenuItemSelected(int featureId, MenuItem item) {
    if (featureId == WindowUtils.FEATURE_VOICE_COMMANDS ||
            featureId == Window.FEATURE_OPTIONS_PANEL) {
    ...
}

Con queste modifiche, puoi toccare o dire ok Glass per visualizzare il menu.

Utilizzo di comandi vocali non in elenco per lo sviluppo

Se desideri distribuire i tuoi prodotti in vetro, devi utilizzare i file principali approvati comandi vocali in VoiceTriggers.Command e comandi vocali contestuali approvati in ContextualMenus.Command.

Se vuoi usare comandi vocali che non sono disponibili in GDK, puoi richiedere un'autorizzazione Android nel tuo file AndroidManifest.xml:

<uses-permission
     android:name="com.google.android.glass.permission.DEVELOPMENT" />

Nota: questa funzionalità è solo a scopo di sviluppo.

Utilizzare i comandi vocali principali non in elenco

1. Dichiara un valore stringa in res/values/strings.xml che definisce il nome del trigger vocale. Se vuoi, puoi dichiarare un prompt vocale per visualizzare il riconoscimento vocale Glassware prima di avviare Glassware.

   <?xml version="1.0" encoding="utf-8"?>
   <resources>
       <string name="glass_voice_trigger">read me a story</string>
       <string name="glass_voice_prompt">what story?</string>
   </resources>
   

2. Crea una risorsa XML per il trigger vocale in res/xml/<my_voice_trigger>.xml. Per i comandi vocali non in elenco, devi usare l'attributo keyword anziché l'attributo command utilizzato per le comandi vocali. L'attributo keyword deve essere un riferimento alla stringa che definisce il comando vocale. Per un semplice trigger vocale che avvia attività o servizio immediatamente, è sufficiente specificare l'elemento trigger:

   <?xml version="1.0" encoding="utf-8"?>
   <trigger keyword="@string/glass_voice_trigger" />
   

   Per creare un attivatore vocale che richieda all'utente di pronunciare un altro comando una frase prima di iniziare l'attività o il servizio, includi un elemento di input anche:

   <?xml version="1.0" encoding="utf-8"?>
   <trigger keyword="@string/glass_voice_trigger">
       <input prompt="@string/glass_voice_prompt" />
   </trigger>
   

Utilizzare i comandi vocali contestuali non in elenco

Quando crei voci di menu, utilizza qualsiasi testo per il titolo della voce. Ad esempio:

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Use the constants defined in the ContextualMenus.Command enum-->
    <item
        android:id="@+id/pizza_menu_item"
        android:title="@string/find_pizza" />
</menu>

Avvio del riconoscimento vocale in corso...

Il servizio Glassware per il riconoscimento vocale attende che gli utenti parlino e restituisce il testo trascritto al termine dell'operazione. Per avviare l'attività:

1. Chiama il numero startActivityForResult() con l'intent ACTION_RECOGNIZE_SPEECH. All'avvio dell'attività sono supportati i seguenti extra per intent:
   • EXTRA_PROMPT
   • EXTRA_RESULTS_PENDINGINTENT
   • EXTRA_RESULTS_PENDINGINTENT_BUNDLE

2. Sostituisci il valore onActivityResult() per ricevere il testo trascritto EXTRA_RESULTS intent extra. Questo callback viene chiamato quando gli utenti hanno finito di parlare.

   private static final int SPEECH_REQUEST = 0;
   
   private void displaySpeechRecognizer() {
       Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
       startActivityForResult(intent, SPEECH_REQUEST);
   }
   
   @Override
   protected void onActivityResult(int requestCode, int resultCode,
           Intent data) {
       if (requestCode == SPEECH_REQUEST && resultCode == RESULT_OK) {
           List<String> results = data.getStringArrayListExtra(
                   RecognizerIntent.EXTRA_RESULTS);
           String spokenText = results.get(0);
           // Do something with spokenText.
       }
       super.onActivityResult(requestCode, resultCode, data);
   }