Android Things: Integrando el Asistente de Google

() translation by (you can also view the original English article)

Con el crecimiento de la Internet de las Cosas (IoT, del inglés Internet of Things), desarrolladores a ingenieros tuvieron que repensar cómo interactúan los usuarios con sus dispositivos en el día a día.

Si bien las pantallas funcionan bien con los sitios web y la mayoría de las apps, los dispositivos que se comunican con el mundo real pueden resultar un poco más tediosos de operar si tienes que utilizar múltiples botones o una pantalla para hacerlos funcionar. Una de las maneras de resolver esto es habilitar comandos de voz en tus dispositivos.

En este tutorial aprenderás acerca del Asistente de Google y cómo puedes integrarlo con tus dispositivos IoT.

Si necesitas un poco de contexto acerca de Android Things antes de comenzar, revisa algunos de mis otros posts aquí en Envato Tuts+.

SDK del Asistente

El SDK del Asistente de Google te permite añadir comandos de voz con detección de palabras clave, procesamiento de lenguajes naturales, y otras funciones de aprendizaje de máquinas a tus dispositivos IoT. Es mucho lo que se puede hacer con el SDK del Asistente, pero este tutorial sólo se enfocará en lo básico: cómo puedes integrarlo en tus dispositivos IoT para poder hacer preguntas, obtener información, e interactuar con la funcionalidad estándar del Asistente.

En cuanto a los requisitos de hardware, tienes algunas opciones. Puedes utilizar un Raspberry Pi con Android Things instalado, en conjunto con un Kit de Voz AIY.

O puedes emplear un parlante estándar con un conector AUX y un micrófono USB.

Además, puedes utilizar cualquier otra configuración de hardware I²S. Aunque no discutiremos I²S en detalle en este tutorial, vale la pena destacar que el Kit de Voz utilizará este protocolo. Una vez que tengas tu micrófono y tu parlante preparados, también necesitarás agregarle un botón a tu dispositivo. Este botón deberá registrar dos estados: presionado y soltado. Puedes lograr esto con un botón de arcade, o un botón estándar con un botón estándar con una resistencia pull-down conectada a uno de los polos.

Credenciales

Una vez que hayas configurado tu hardware, es hora de integrar el SDK del Asistente a tu dispositivo. Primero, necesitarás crear un nuevo archivo de credenciales para tu dispositivo. Puedes leer las instrucciones para esto en la documentación del Asistente de Google. Una vez que tengas tu archivo credentials.json, debes colocarlo dentro del directorio res/raw de tu módulo de Android Things.

credentialsjson file in the resraw directory

Luego de crear tus credenciales con Google, necesitarás declarar algunos permisos para tu app. Abre el archivo AndroidManifest.xml y escribe las siguientes líneas dentro de la etiqueta manifest, pero antes de la etiqueta application.

1	<uses-permission android:name="android.permission.RECORD_AUDIO" />
2	<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
3	<uses-permission android:name="android.permission.INTERNET" />
4	<uses-permission android:name="com.google.android.things.permission.MANAGE_AUDIO_DRIVERS" />

Vale la pena destacar que tendrás que reiniciar tu dispositivo luego de instalar la app con estos permisos para que puedan ser administrados.

Luego, necesitas copiar el módulo gRPC en tu app para que se comunique con el dispositivo. Esto puede tornarse un poco complicado, por lo cual el mejor lugar para descargarlo es de la app de ejemplo de Google Assistant Android Things, que puede encontrarse en la cuenta de GitHub de Android Things. Luego, deberás actualizar tu archivo settings.gradle para que incluya el nuevo módulo.

1	include ':mobile', ':things', ':grpc'

Luego de actualizar settings.gradle, incluye el módulo como una dependencia de tu módulo things, escribiendo la siguiente línea en el archivo build.gradle del módulo things, e incluyendo el driver del botón de Google (lo necesitarás para activar el micrófono), y de manera opcional el driver de Voice Hat si estás usando ese hardware.

compile project(':grpc')
 compile 'com.google.android.things.contrib:driver-button:0.4'
 
 //optional
 compile 'com.google.android.things.contrib:driver-voicehat:0.2'

También necesitarás incluir protobuf como dependencia en tu archivo build.gradle ubicado a nivel de proyecto.

1	classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.0"

Luego, incluye la librería oauth2 en tu proyecto, abriendo el archivo build.gradle del módulo things y escribiendo lo siguiente dentro del nodo dependencies:

1	compile('com.google.auth:google-auth-library-oauth2-https:0.6.0') {
2	exclude group: 'org.apache.httpcomponents', module: 'httpclient'
3	}

Puedes hallar conflictos aquí si tu proyecto contiene la dependencia Espresso, con un mensaje de error similar al siguiente:

Warning:Conflict with dependency 'com.google.code.findbugs:jsr305' in project ':things'. Resolved versions for app (1.3.9) and test app (2.0.1) differ. See http://g.co/androidstudio/app-test-app-conflict for details.

De ser así, simplemente borra la dependencia Espresso de build.gradle.

Luego de sincronizar tu proyecto, crea una clase nueva llamada Credentials.java para acceder a tus credenciales.

public class Credentials {
  static UserCredentials fromResource(Context context, int resourceId)
  throws IOException, JSONException {
         InputStream is = context.getResources().openRawResource(resourceId);
         byte[] bytes = new byte[is.available()];
         is.read(bytes);
         JSONObject json = new JSONObject(new String(bytes, "UTF-8"));
             return new UserCredentials(json.getString("client_id"),
                 json.getString("client_secret"),
                 json.getString("refresh_token")
             );
         }
     }
 }

Clase Auxiliar Embedded Assistant

Una vez creada la clase Credentials.java, es momento de crear una nueva clase llamada EmbeddedAssistant.java. Esta es una clase auxiliar originalmente escrita por ingenieros de Google para integrar de manera sencilla el Asistente de Google para Android Things. Aunque esta clase es muy fácil de utilizar, simplemente incluyéndola en tu proyecto, queremos adentrarnos en ella y comprender cómo funciona.

Lo primero que harás es crear dos clases abstractas internas que servirán para manejar callbacks en la conversación y peticiones a la API del Asistente.

public class EmbeddedAssistant {
 
     public static abstract class RequestCallback {
         public void onRequestStart() {}
         public void onAudioRecording() {}
         public void onSpeechRecognition(String utterance) {}
     }
 
     public static abstract class ConversationCallback {
       public void onResponseStarted() {}
 	    public void onResponseFinished() {}
 	    public void onConversationEvent(EventType eventType) {}
 	    public void onAudioSample(ByteBuffer audioSample) {}
 	    public void onConversationError(Status error) {}
 	    public void onError(Throwable throwable) {}
 	    public void onVolumeChanged(int percentage) {}
 	    public void onConversationFinished() {}
 	}
 }

Una vez que tus dos clases internas estén listas, continúa definiendo el siguiente conjunto de variables globales al principio de tu clase. La mayor parte de estas serán inicializadas luego en este archivo. Estos valores se usan para mantener registro del estado del dispositivo y sus interacciones con la API del Asistente.

private static final String ASSISTANT_API_ENDPOINT = "embeddedassistant.googleapis.com";
 private static final int AUDIO_RECORD_BLOCK_SIZE = 1024;
 
 private RequestCallback mRequestCallback;
 private ConversationCallback mConversationCallback;
 
 //Used for push-to-talk functionality
 private ByteString mConversationState;
 private AudioInConfig mAudioInConfig;
 private AudioOutConfig mAudioOutConfig;
 private AudioTrack mAudioTrack;
 private AudioRecord mAudioRecord;
 private int mVolume = 100; // Default to maximum volume.
 
 private UserCredentials mUserCredentials;
 
 private MicrophoneMode mMicrophoneMode;
 private HandlerThread mAssistantThread;
 private Handler mAssistantHandler;
 
 // gRPC client and stream observers.
 private int mAudioOutSize; // Tracks the size of audio responses to determine when it ends.
 private EmbeddedAssistantGrpc.EmbeddedAssistantStub mAssistantService;
 private StreamObserver<ConverseRequest> mAssistantRequestObserver;
 

Manejando las Respuestas de la API

Mientras que el código anterior tiene un objeto StreamObserver<ConverseRequest> para las peticiones a la API del Asistente, también necesitarás uno para las respuestas. Este objeto consistirá de una cláusula switch que chequea el estado de la respuesta y luego la maneja de acuerdo a este.

private StreamObserver<ConverseResponse> mAssistantResponseObserver =
     new StreamObserver<ConverseResponse>() {
         @Override
         public void onNext(ConverseResponse value) {
             switch (value.getConverseResponseCase()) {

El primer caso chequea que un usuario ha terminado de hablar y utiliza ConversationCallback para hacerle saber al resto de la clase que una respuesta es inminente.

case EVENT_TYPE:
     mConversationCallback.onConversationEvent(value.getEventType());
     if (value.getEventType() == EventType.END_OF_UTTERANCE) {
         mConversationCallback.onResponseStarted();
     }
     break;

El siguiente caso comprobará y actualizará la conversación, el volumen, y el estado del micrófono.

case RESULT:
     // Update state.
     mConversationState = value.getResult().getConversationState();
     
     // Update volume.
     if (value.getResult().getVolumePercentage() != 0) {
         int volumePercentage = value.getResult().getVolumePercentage();
         mVolume = volumePercentage;
         mAudioTrack.setVolume(AudioTrack.getMaxVolume()
                 * volumePercentage / 100.0f);
         mConversationCallback.onVolumeChanged(volumePercentage);
     }
     
     if (value.getResult().getSpokenRequestText() != null &&
             !value.getResult().getSpokenRequestText().isEmpty()) {
         mRequestCallback.onSpeechRecognition(value.getResult()
                 .getSpokenRequestText());
     }
     
     // Update microphone mode.
     mMicrophoneMode = value.getResult().getMicrophoneMode();
     break;

El tercer caso tomará un resultado de audio y lo reproducirá para el usuario.

case AUDIO_OUT:
     if (mAudioOutSize <= value.getAudioOut().getSerializedSize()) {
         mAudioOutSize = value.getAudioOut().getSerializedSize();
     } else {
         mAudioOutSize = 0;
         onCompleted();
     }
     
     final ByteBuffer audioData =
             ByteBuffer.wrap(value.getAudioOut().getAudioData().toByteArray());
     mAudioTrack.write(audioData, audioData.remaining(),
             AudioTrack.WRITE_BLOCKING);
     mConversationCallback.onAudioSample(audioData);
     break;

El caso final simplemente devolverá errores que pudieran haber ocurrido durante el proceso de conversación.

1	case ERROR:
2	mConversationCallback.onConversationError(value.getError());
3	break;

Los dos métodos finales dentro de este flujo manejan estados de error y hacen la limpieza cuando se completa un resultado de la conversación.

@Override
 public void onError(Throwable t) {
     mConversationCallback.onError(t);
 }
 
 @Override
 public void onCompleted() {
     mConversationCallback.onResponseFinished();
     if (mMicrophoneMode == MicrophoneMode.DIALOG_FOLLOW_ON) {
         // Automatically start a new request
         startConversation();
     } else {
         // The conversation is done
         mConversationCallback.onConversationFinished();
     }
 }

Streaming de Audio

Luego, necesitarás crear un Runnable que manejará streaming de audio en un thread diferente.

private Runnable mStreamAssistantRequest = new Runnable() {
     @Override
     public void run() {
         ByteBuffer audioData = ByteBuffer.allocateDirect(AUDIO_RECORD_BLOCK_SIZE);
         int result = mAudioRecord.read(audioData, audioData.capacity(),
                 AudioRecord.READ_BLOCKING);
         if (result < 0) {
             return;
         }
         mRequestCallback.onAudioRecording();
         mAssistantRequestObserver.onNext(ConverseRequest.newBuilder()
                 .setAudioIn(ByteString.copyFrom(audioData))
                 .build());
         mAssistantHandler.post(mStreamAssistantRequest);
     }
 };

Creando el Asistente

Ahora que tus variables globales están definidas, es hora de crear el EmbeddedAssistant. Tendrás que obtener las credenciales para tu app utilizando la clase Credentials.java creada anteriormente.

1	public static UserCredentials generateCredentials(Context context, int resourceId)
2	throws IOException, JSONException {
3	return Credentials.fromResource(context, resourceId);
4	}

Para que pueda instanciarse a sí misma, esta clase utiliza un constructor privado y el patrón builder.

private EmbeddedAssistant() {}
 
 public static class Builder {
     private EmbeddedAssistant mEmbeddedAssistant;
     private int mSampleRate;
 
     public Builder() {
         mEmbeddedAssistant = new EmbeddedAssistant();
     }

La clase interna Builder contiene múltiples métodos para inicializar los valores dentro de la clase EmbeddedAssistant, como frecuencia de muestreo, volumen, y credenciales de usuario. Una vez invocado el método build(), todos los valores definidos se configurarán en el EmbeddedAssistant, los objetos globales necesarios para operar se iniciarán, y se disparará un error si falta algún dato necesario.

    public Builder setRequestCallback(RequestCallback requestCallback) {
         mEmbeddedAssistant.mRequestCallback = requestCallback;
         return this;
     }
 
     public Builder setConversationCallback(ConversationCallback responseCallback) {
         mEmbeddedAssistant.mConversationCallback = responseCallback;
         return this;
     }
 
     public Builder setCredentials(UserCredentials userCredentials) {
         mEmbeddedAssistant.mUserCredentials = userCredentials;
         return this;
     }
 
     public Builder setAudioSampleRate(int sampleRate) {
         mSampleRate = sampleRate;
         return this;
     }
 
     public Builder setAudioVolume(int volume) {
         mEmbeddedAssistant.mVolume = volume;
         return this;
     }
 
     public EmbeddedAssistant build() {
         if (mEmbeddedAssistant.mRequestCallback == null) {
             throw new NullPointerException("There must be a defined RequestCallback");
         }
         if (mEmbeddedAssistant.mConversationCallback == null) {
             throw new NullPointerException("There must be a defined ConversationCallback");
         }
         if (mEmbeddedAssistant.mUserCredentials == null) {
             throw new NullPointerException("There must be provided credentials");
         }
         if (mSampleRate == 0) {
             throw new NullPointerException("There must be a defined sample rate");
         }
         final int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;
 
         // Construct audio configurations.
         mEmbeddedAssistant.mAudioInConfig = AudioInConfig.newBuilder()
                 .setEncoding(AudioInConfig.Encoding.LINEAR16)
                 .setSampleRateHertz(mSampleRate)
                 .build();
         mEmbeddedAssistant.mAudioOutConfig = AudioOutConfig.newBuilder()
                 .setEncoding(AudioOutConfig.Encoding.LINEAR16)
                 .setSampleRateHertz(mSampleRate)
                 .setVolumePercentage(mEmbeddedAssistant.mVolume)
                 .build();
 
         // Construct AudioRecord & AudioTrack
         AudioFormat audioFormatOutputMono = new AudioFormat.Builder()
                 .setChannelMask(AudioFormat.CHANNEL_OUT_MONO)
                 .setEncoding(audioEncoding)
                 .setSampleRate(mSampleRate)
                 .build();
         int outputBufferSize = AudioTrack.getMinBufferSize(audioFormatOutputMono.getSampleRate(),
                 audioFormatOutputMono.getChannelMask(),
                 audioFormatOutputMono.getEncoding());
         mEmbeddedAssistant.mAudioTrack = new AudioTrack.Builder()
                 .setAudioFormat(audioFormatOutputMono)
                 .setBufferSizeInBytes(outputBufferSize)
                 .build();
         mEmbeddedAssistant.mAudioTrack.setVolume(mEmbeddedAssistant.mVolume *
                 AudioTrack.getMaxVolume() / 100.0f);
         mEmbeddedAssistant.mAudioTrack.play();
 
         AudioFormat audioFormatInputMono = new AudioFormat.Builder()
                 .setChannelMask(AudioFormat.CHANNEL_IN_MONO)
                 .setEncoding(audioEncoding)
                 .setSampleRate(mSampleRate)
                 .build();
         int inputBufferSize = AudioRecord.getMinBufferSize(audioFormatInputMono.getSampleRate(),
                 audioFormatInputMono.getChannelMask(),
                 audioFormatInputMono.getEncoding());
         mEmbeddedAssistant.mAudioRecord = new AudioRecord.Builder()
                 .setAudioSource(AudioSource.VOICE_RECOGNITION)
                 .setAudioFormat(audioFormatInputMono)
                 .setBufferSizeInBytes(inputBufferSize)
                 .build();
 
         return mEmbeddedAssistant;
     }
 }
 

Conectándose a la API del Asistente

Luego de que el EmbeddedAssistant ha sido creado, debemos llamar al método connect() para poder conectarnos a la API del Asistente.

public void connect() {
     mAssistantThread = new HandlerThread("assistantThread");
     mAssistantThread.start();
     mAssistantHandler = new Handler(mAssistantThread.getLooper());
 
     ManagedChannel channel = ManagedChannelBuilder.forTarget(ASSISTANT_API_ENDPOINT).build();
     mAssistantService = EmbeddedAssistantGrpc.newStub(channel)
             .withCallCredentials(MoreCallCredentials.from(mUserCredentials));
 }

Luego de conectarte a la API, emplearás dos métodos para comenzar y detener conversaciones. Estos métodos enviarán objetos Runnable a mAssistantHandler, para pasar objetos de estado de la conversación hacia los flujos de petición y respuesta.

public void startConversation() {
     mAudioRecord.startRecording();
     mRequestCallback.onRequestStart();
     mAssistantHandler.post(new Runnable() {
         @Override
         public void run() {
             mAssistantRequestObserver = mAssistantService.converse(mAssistantResponseObserver);
             ConverseConfig.Builder converseConfigBuilder = ConverseConfig.newBuilder()
                     .setAudioInConfig(mAudioInConfig)
                     .setAudioOutConfig(mAudioOutConfig);
             if (mConversationState != null) {
                 converseConfigBuilder.setConverseState(ConverseState.newBuilder()
                         .setConversationState(mConversationState)
                         .build());
             }
             mAssistantRequestObserver.onNext(
                     ConverseRequest.newBuilder()
                             .setConfig(converseConfigBuilder.build())
                             .build());
         }
     });
     mAssistantHandler.post(mStreamAssistantRequest);
 }
 
 public void stopConversation() {
     mAssistantHandler.post(new Runnable() {
         @Override
         public void run() {
             mAssistantHandler.removeCallbacks(mStreamAssistantRequest);
             if (mAssistantRequestObserver != null) {
                 mAssistantRequestObserver.onCompleted();
                 mAssistantRequestObserver = null;
             }
         }
     });
 
     mAudioRecord.stop();
     mAudioTrack.play();
     mConversationCallback.onConversationFinished();
 }

Apagado

Finalmente el método destroy() será utilizado durante el apagado, cuando tu app se cierre y no requiera más acceso a la API del Asistente.

public void destroy() {
     mAssistantHandler.post(new Runnable() {
         @Override
         public void run() {
             mAssistantHandler.removeCallbacks(mStreamAssistantRequest);
         }
     });
     mAssistantThread.quitSafely();
     if (mAudioRecord != null) {
         mAudioRecord.stop();
         mAudioRecord = null;
     }
     if (mAudioTrack != null) {
         mAudioTrack.stop();
         mAudioTrack = null;
     }
 }

Utilizando el Asistente

Una vez desarrolladas tus clases auxiliares, es momento de utilizarlas. Lo harás editando tu clase MainActivity de Android Things para que interactúe con el EmbeddedAssistant y el hardware para controlar el Google Assistant. Primero, agrega la interfaz Button.OnButtonEventListener a tu Activity.

1	public class MainActivity extends Activity implements Button.OnButtonEventListener {

A continuación necesitarás agregar las variables miembro y las constantes necesarias para tu app. Estos valores controlarán el rebote del botón que dispara el Asistente, así como también el volumen, el formato de audio, la clase UserCredentials que creaste anteriormente, y el hardware de tu dispositivo.

private static final int BUTTON_DEBOUNCE_DELAY_MS = 20;
 private static final String PREF_CURRENT_VOLUME = "current_volume";
 private static final int SAMPLE_RATE = 16000;
 private static final int ENCODING = AudioFormat.ENCODING_PCM_16BIT;
 private static final int DEFAULT_VOLUME = 100;
 
 private int initialVolume = DEFAULT_VOLUME;
 
 private static final AudioFormat AUDIO_FORMAT_STEREO =
         new AudioFormat.Builder()
                 .setChannelMask(AudioFormat.CHANNEL_IN_STEREO)
                 .setEncoding(ENCODING)
                 .setSampleRate(SAMPLE_RATE)
                 .build();
 
 // Hardware peripherals.
 private VoiceHat mVoiceHat;
 private Button mButton;
 private EmbeddedAssistant mEmbeddedAssistant;
 private UserCredentials userCredentials;

Una vez que tus constantes estén definidas, necesitarás crear algunos objetos callback que serán utilizados para las conversaciones y peticiones al asistente.

private ConversationCallback mConversationCallback = new ConversationCallback() {
     @Override
     public void onConversationEvent(EventType eventType) {}
 
     @Override
     public void onAudioSample(ByteBuffer audioSample) {}
 
     @Override
     public void onConversationError(Status error) {}
 
     @Override
     public void onError(Throwable throwable) {}
 
     @Override
     public void onVolumeChanged(int percentage) {
         SharedPreferences.Editor editor = PreferenceManager
                 .getDefaultSharedPreferences(AssistantActivity.this)
                 .edit();
         editor.putInt(PREF_CURRENT_VOLUME, percentage);
         editor.apply();
     }
 
     @Override
     public void onConversationFinished() {}
 };
 
 private RequestCallback mRequestCallback = new RequestCallback() {
     @Override
     public void onRequestStart() {
         //starting assistant request, enable microphones
     }
 
     @Override
     public void onSpeechRecognition(String utterance) {}
 };

En mConversationCallback, notarás que guardamos un porcentaje de variación del volumen en una preferencia compartida. Esto permite que el volumen del dispositivo permanezca constante para tus usuarios, inclusive después del reinicio.

Como el Asistente trabaja de manera asincrónica en tu dispositivo, inicializarás todo para usar la API del Asistente en el método onCreate(), invocando un conjunto de métodos auxiliares que definiremos en el resto de este tutorial.

@Override
 protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
 
     initVoiceHat();
     initButton();
     initVolume();
     initUserCredentials();
     initEmbeddedAssistant();
 }

El primer método auxiliar es initVoiceHat(). Si se conecta Voice Hat a un Raspberry Pi, este método iniciará el dispositivo para que los usuarios puedan utilizar el micrófono y el parlante integrados. Si no hay un Voice Hat conectado, entonces se pueden utilizar un parlante AUX estándar y un micrófono USB, y serán detectados automáticamente. Voice Hat utiliza I²S para manejar periféricos de audio en el bus, y está contenido en una clase driver escrita por Google.

private void initVoiceHat() {
     PeripheralManagerService pioService = new PeripheralManagerService();
     List<String> i2sDevices = pioService.getI2sDeviceList();
     if (i2sDevices.size() > 0) {
         try {
             mVoiceHat = new VoiceHat(
                     BoardDefaults.getI2SDeviceForVoiceHat(),
                     BoardDefaults.getGPIOForVoiceHatTrigger(),
                     AUDIO_FORMAT_STEREO
             );
             mVoiceHat.registerAudioInputDriver();
             mVoiceHat.registerAudioOutputDriver();
         } catch (IllegalStateException e) {}
     }
 }

En este ejemplo, el Asistente sólo responderá al mantener presionado un botón. Este botón se inicializa y configura de la siguiente manera:

private void initButton() {
     try {
         mButton = new Button(BoardDefaults.getGPIOForButton(),
                 Button.LogicState.PRESSED_WHEN_LOW);
         mButton.setDebounceDelay(BUTTON_DEBOUNCE_DELAY_MS);
         mButton.setOnButtonEventListener(this);
     } catch( IOException e ) {}
 }

Cuando el botón es presionado, el Asistente comenzará a escuchar, a la espera de una nueva conversación.

@Override
 public void onButtonEvent(Button button, boolean pressed) {
     if (pressed) {
         mEmbeddedAssistant.startConversation();
     }
 }

Puedes encontrar más información acerca de GPIO y Android Things en mi tutorial acerca de entrada y salida con Android Things.

Android SDK

Android Things: Entrada/Salida Periféricas

Paul Trebilcox-Ruiz

Como hemos almacenado información en las SharedPreferences de nuestro dispositivo, podemos accederlas directamente para inicializar el volumen del dispositivo.

1	private void initVolume() {
2	SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
3	initialVolume = preferences.getInt(PREF_CURRENT_VOLUME, DEFAULT_VOLUME);
4	}

El SDK del Asistente requiere autenticación para ser utilizado. Afortunadamente, hemos creado un método en la clase EmbeddedAssistant anteriormente en este tutorial, específicamente para esta situación.

private void initUserCredentials() {
     userCredentials = null;
     try {
         userCredentials = EmbeddedAssistant.generateCredentials(this, R.raw.credentials);
     } catch (IOException | JSONException e) {}
 }

El último método auxiliar invocado en onCreate() inicializará el objeto EmbeddedAssistant y lo conectará con la API.

private void initEmbeddedAssistant() {
     mEmbeddedAssistant = new EmbeddedAssistant.Builder()
             .setCredentials(userCredentials)
             .setAudioSampleRate(SAMPLE_RATE)
             .setAudioVolume(currentVolume)
             .setRequestCallback(mRequestCallback)
             .setConversationCallback(mConversationCallback)
             .build();
 
     mEmbeddedAssistant.connect();
 }

Por último, necesitarás apagar correctamente tus periféricos, actualizando el método onDestroy() de tu Activity.

@Override
 protected void onDestroy() {
     super.onDestroy();
     if (mButton != null) {
         try {
             mButton.close();
         } catch (IOException e) {}
 
         mButton = null;
     }
 
     if (mVoiceHat != null) {
         try {
             mVoiceHat.unregisterAudioOutputDriver();
             mVoiceHat.unregisterAudioInputDriver();
             mVoiceHat.close();
         } catch (IOException e) {}
         mVoiceHat = null;
     }
     mEmbeddedAssistant.destroy();
 }

¡Ahora, deberías ser capaz de interactuar con tu dispositivo Android Things como si fuera un Google Home!

Conclusión

En este tutorial, has aprendido acerca del Asistente de Google y cómo puede integrarse en tus aplicaciones Android Things. Esta función les da a tus usuarios una nueva manera de interactuar y controlar tu dispositivo, así como acceso a las diversas funcionalidades de Google disponibles. Esta es sólo una parte de las fantásticas funciones que pueden existir dentro de una app Android Things, y te permiten crear increíbles dispositivos nuevos para tus usuarios.

Mientras estés aquí, ¡revisa algunas de mis otras publicaciones acerca de Android Things en Envato Tuts+!