Indonesian (Bahasa Indonesia) translation by AaliyaA (you can also view the original English article)
Dengan pertumbuhan Internet of Things (IoT), pengembang dan teknisi harus memikirkan kembali bagaimana pengguna berinteraksi dengan perangkat setiap hari.
Sementara layar bekerja dengan baik untuk situs web dan aplikasi kebanyakan, perangkat yang berinteraksi dengan dunia nyata bisa menjadi sedikit lebih membosankan jika anda harus menggunakan beberapa tombol atau layar untuk berfungsi. Salah satu cara sekitar ini adalah dengan mengaktifkan kontrol suara pada perangkat anda.
Dalam tutorial ini anda akan belajar tentang Google Asisten dan bagaimana anda dapat menambahkannya ke perangkat Android IoT hal anda.
Jika Anda memerlukan sedikit latar belakang pada hal-hal Android sebelum anda mulai, lihat beberapa posting saya yang lain di sini di Envato Tuts+.
Asisten SDK
SDK Google Asisten memungkinkan anda menambahkan kontrol suara dengan deteksi kata kunci, pemrosesan bahasa alami, dan fitur pembelajaran mesin lainnya ke perangkat IoT anda. Ada banyak hal yang bisa dilakukan dengan Asisten SDK, tapi di tutorial ini hanya akan fokus pada hal-hal mendasar: bagaimana anda bisa memasukkannya ke perangkat Android Things anda untuk mengajukan pertanyaan, mendapatkan informasi, dan berinteraksi dengan standar "di luar kotak "Asisten fungsionalitas.
Sejauh persyaratan perangkat keras, anda memiliki beberapa pilihan. Anda dapat menggunakan Raspberry Pi yang melintas dengan Android Things dengan AIY Voice Kit.
Atau anda dapat menggunakan speaker standar dengan konektor AUX dan USB mikrofon.
Selain itu, anda dapat menggunakan konfigurasi perangkat keras I²S lainnya. Meskipun kami tidak akan membahas I²S secara rinci dalam tutorial ini, perlu dicatat bahwa Voice Kit akan menggunakan protokol ini. Begitu anda memasang mikrofon dan speaker, anda juga perlu menambahkan tombol ke perangkat anda. Tombol ini akan perlu untuk melacak dua status: ditekan dan dilepaskan. Anda dapat mencapai ini dengan arcade multi-cabang tombol atau tombol standar dengan sebuah resistor tarik-turun yang melekat pada salah satu tiang.
Kredensial
Setelah anda menghubungkan perangkat keras anda, sekarang saatnya menambahkan Asisten SDK ke perangkat anda. Pertama, anda perlu membuat file kredensial baru untuk perangkat anda. Anda dapat menemukan petunjuk untuk hal ini di dokumen Google Asisten. Setelah anda memiliki file credentials.json anda, anda perlu memasukkannya ke direktori res/raw dari modul Android Things Anda.
Setelah kredensial anda dibuat dengan Google, anda harus menyatakan beberapa izin untuk aplikasi anda. Buka file AndroidManifest.xml dan tambahkan baris berikut di dalam tag manifest, namun sebelum tag application.
<uses-permission android:name="android.permission.RECORD_AUDIO" /> <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" /> <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="com.google.android.things.permission.MANAGE_AUDIO_DRIVERS" />
Perlu dicatat bahwa anda perlu me-restart perangkat anda setelah menginstal aplikasi dengan izin ini agar bisa diberikan.
Selanjutnya anda perlu menyalin modul gRPC ke aplikasi anda untuk berkomunikasi dengan perangkat rumah. Ini menjadi sedikit rumit, jadi tempat terbaik untuk mendapatkannya adalah dari contoh aplikasi Google Asisten Android Things, yang dapat ditemukan di akun Android Things GitHub. Anda kemudian perlu memperbarui file settings.gradle anda untuk mencerminkan modul baru.
include ':mobile', ':things', ':grpc'
Setelah memperbarui settings.gradle, sertakan modul sebagai dependensi pada modul hal-hal anda dengan menyertakan baris berikut dalam file modul build.gradle dan termasuk driver tombol Google (anda memerlukan ini untuk mengaktifkan mikrofon) dan driver Voice Hat opsional jika anda menggunakan perangkat keras itu.
compile project(':grpc')
compile 'com.google.android.things.contrib:driver-button:0.4'
//optional
compile 'com.google.android.things.contrib:driver-voicehat:0.2'
Anda juga harus menyertakan protobuf sebagai depedensi di file build.gradle tingkat proyek anda.
classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.0"
Selanjutnya, mari sertakan library oauth2 di proyek kita dengan membuka modul things file build.gradle dan menambahkan hal-hal berikut di bawah dependencies node:
compile('com.google.auth:google-auth-library-oauth2-https:0.6.0') {
exclude group: 'org.apache.httpcomponents', module: 'httpclient'
}
Anda mungkin mengalami konflik di sini jika proyek anda memiliki dependensi Espresso, dengan pesan kesalahan serupa dengan ini:
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.
Jika demikian, hapus saja dependensi Espresso dari build.gradle.
Setelah mensinkronisasi proyek anda, buat class baru bernama Credentials.java untuk mengakses kredensial Anda.
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")
);
}
}
}
Class Assistant Helper Bawaan
Begitu class Credentials.java anda dibuat, sekarang saatnya membuat class baru bernama EmbeddedAssistant.java. Ini adalah class pembantu yang pada awalnya ditulis oleh para insinyur di Google untuk dengan mudah membungkus Asisten Google untuk Android Things. Meskipun class ini cukup mudah digunakan hanya dengan memasukkannya ke dalam proyek anda, kami ingin mendalaminya dan memahami bagaimana cara kerja sebenarnya.
Hal pertama yang anda akan lakukan adalah membuat dua class abstrak inti yang akan digunakan untuk menangani callback dalam percakapan dan permintaan ke API asisten.
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() {}
}
}
Setelah dua class inti anda ditulis, lanjutkan dan tentukan serangkaian nilai global berikut di bagian atas kelas anda. Sebagian besar ini akan diinisialisasi nanti dalam file ini. Nilai ini digunakan untuk melacak status perangkat dan interaksi dengan API asisten.
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;
Penanganan Respon API
Sementara di atas mempunyai objek StreamObserver<Conserve Request> untuk permintaan ke Asisten API, anda juga memerlukan satu untuk tanggapan. Objek ini akan terdiri dari pernyataan switch yang memeriksa keadaan respons dan kemudian menanganinya sesuai dengan itu.
private StreamObserver<ConverseResponse> mAssistantResponseObserver =
new StreamObserver<ConverseResponse>() {
@Override
public void onNext(ConverseResponse value) {
switch (value.getConverseResponseCase()) {
Kasus pertama periksa sampai akhir pengguna berbicara dan gunakan ConversationCallback untuk membiarkan seluruh class tahu bahwa sebuah respon akan segera terjadi.
case EVENT_TYPE:
mConversationCallback.onConversationEvent(value.getEventType());
if (value.getEventType() == EventType.END_OF_UTTERANCE) {
mConversationCallback.onResponseStarted();
}
break;
Kasus selanjutnya akan memeriksa dan perbarui percakapan, volume, dan mikrofon negara.
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;
Kasus ketiga akan mengambil hasil audio dan memainkannya kembali untuk pengguna.
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;
Kasus akhir hanya akan meneruskan kesalahan yang terjadi selama proses percakapan.
case ERROR:
mConversationCallback.onConversationError(value.getError());
break;
Dua metode terakhir dalam urutan ini menangani keadaan kesalahan dan pembersihan saat menyelesaikan hasil percakapan.
@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 Audio
Selanjutnya, anda perlu membuat Runnable yang akan menangani streaming audio pada thread yang berbeda.
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);
}
};
Menciptakan Asisten
Setelah nilai global anda ditetapkan, saatnya untuk membahas framework untuk menciptakan EmbeddedAssistant. Anda harus dapat mengambil kredensial untuk aplikasi anda menggunakan class Credentials.java yang telah dibuat sebelumnya.
public static UserCredentials generateCredentials(Context context, int resourceId)
throws IOException, JSONException {
return Credentials.fromResource(context, resourceId);
}
Agar bisa instantiate sendiri, class ini menggunakan private constructor dan builder pattern.
private EmbeddedAssistant() {}
public static class Builder {
private EmbeddedAssistant mEmbeddedAssistant;
private int mSampleRate;
public Builder() {
mEmbeddedAssistant = new EmbeddedAssistant();
}
Class Builder inti berisi beberapa metode untuk menginisialisasi nilai dalam class EmbeddedAssistant, seperti sample rate, volume, dan kredensial pengguna. Setelah metode build() dipanggil, semua nilai yang ditetapkan akan ditetapkan pada EmbeddedAssistant, objek global yang diperlukan untuk operasi akan dikonfigurasi, dan kesalahan akan dibuang jika ada data yang diperlukan hilang.
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;
}
}
Menghubungkan ke API Asisten
Setelah EmbeddedAssistant telah dibuat, metode connect() perlu dipanggil untuk terhubung ke Asisten API.
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));
}
Setelah tersambung ke API, anda akan menggunakan dua metode untuk memulai dan menghentikan percakapan. Metode ini akan memposting objek Runnable ke mAssistantHandler untuk melewati objek percakapan ke urutan permintaan dan respons.
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();
}
Mematikan
Akhirnya, metode destroy() akan digunakan untuk teardown saat aplikasi Anda ditutup dan tidak perlu lagi mengakses Asisten API.
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;
}
}
Menggunakan Asisten
Begitu class pembantu anda selesai, saatnya untuk menggunakannya. Anda akan melakukan ini dengan mengedit class MainActivity Android untuk berinteraksi dengan EmbeddedAssistant dan perangkat keras untuk mengendalikan Asisten Google. Pertama, tambahkan antarmuka Button.OnButtonEventListener ke Activity Anda.
public class MainActivity extends Activity implements Button.OnButtonEventListener {
Selanjutnya anda perlu menambahkan variabel anggota dan konstanta yang akan dibutuhkan oleh aplikasi anda. Nilai-nilai ini akan mengontrol debounce tombol yang memicu Asisten, serta volume, format audio, class UserCredentials yang anda buat sebelumnya, dan perangkat keras untuk perangkat anda.
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;
Setelah konstanta anda didefinisikan, anda perlu membuat beberapa objek callback yang akan digunakan untuk percakapan dan permintaan dengan asisten.
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) {}
};
Dalam mConversationCallback, anda akan melihat bahwa kita menyimpan persentase perubahan volume dalam preferensi bersama. Ini memungkinkan volume perangkat anda tetap konsisten untuk pengguna anda, bahkan di reboot.
Sebagai asisten bekerja secara asinkron pada perangkat anda, anda akan menginisialisasi semuanya untuk menggunakan Asisten API di onCreate() dengan memanggil seperangkat metode pembantu yang akan kita definisikan di sisa tutorial ini.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
initVoiceHat();
initButton();
initVolume();
initUserCredentials();
initEmbeddedAssistant();
}
Metode pembantu pertama adalah initVoiceHat(). Jika pelindung Voice Hat dilekatkan pada Raspberry Pi, metode ini akan menginisialisasi perangkat sehingga pengguna dapat menggunakan mikrofon dan speaker yang terpasang. Jika Voice Hat tidak terpasang, speaker AUX standar dan mikrofon USB dapat digunakan dan akan diarahkan secara otomatis. Voice Hat menggunakan I2S untuk menangani perangkat audio di bus, dan dibungkus oleh class driver yang ditulis oleh 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) {}
}
}
Asisten hanya akan merespon dalam sampel ini sementara tombol pemicu ditekan. Tombol ini diinisialisasi dan dikonfigurasi seperti ini:
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 ) {}
}
Saat tombol ditekan, asisten akan mulai mendengarkan percakapan baru.
@Override
public void onButtonEvent(Button button, boolean pressed) {
if (pressed) {
mEmbeddedAssistant.startConversation();
}
}
Anda dapat menemukan lebih banyak informasi tentang GPIO dan Android Things di my tutorial about input and output with Android Things.
Karena kita menyimpan informasi volume di SharedPreferences perangkat kita, kita dapat mengaksesnya secara langsung untuk menginisialisasi volume perangkat.
private void initVolume() {
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
initialVolume = preferences.getInt(PREF_CURRENT_VOLUME, DEFAULT_VOLUME);
}
Asisten SDK memerlukan otentikasi untuk digunakan. Beruntung kita telah membuat sebuah metode di class EmbeddedAssistant tadi dalam tutorial ini khusus untuk situasi ini.
private void initUserCredentials() {
userCredentials = null;
try {
userCredentials = EmbeddedAssistant.generateCredentials(this, R.raw.credentials);
} catch (IOException | JSONException e) {}
}
Metode pembantu terakhir yang dipanggil di onCreate() akan menginisialisasi objek EmbeddedAssistant dan menghubungkannya ke API.
private void initEmbeddedAssistant() {
mEmbeddedAssistant = new EmbeddedAssistant.Builder()
.setCredentials(userCredentials)
.setAudioSampleRate(SAMPLE_RATE)
.setAudioVolume(currentVolume)
.setRequestCallback(mRequestCallback)
.setConversationCallback(mConversationCallback)
.build();
mEmbeddedAssistant.connect();
}
Hal terakhir yang perlu anda lakukan adalah meruntuhkan perangkat anda dengan benar dengan memperbarui metode onDestroy() di Activity Anda.
@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();
}
Setelah semua ini, anda harus bisa berinteraksi dengan perangkat Android Things anda seolah-olah itu adalah Google Home!
Kesimpulan
Dalam tutorial ini, Anda belajar tentang Google Asisten dan bagaimana hal itu dapat ditambahkan ke aplikasi Android Things anda. Fitur ini memberi pengguna cara baru untuk berinteraksi dengan dan mengendalikan perangkat anda, serta akses ke banyak fitur yang tersedia dari Google. Ini hanya satu bagian dari fitur fantastis yang bisa masuk ke aplikasi Android Things dan memungkinkan anda membuat perangkat baru dan menakjubkan untuk pengguna anda.
Sementara anda di sini, lihat beberapa postingan saya yang lain tentang Android Things di Envato Tuts +!
