[MUSIC PLAYING]
DAVE SMITH: Hello, everyone.
My name is Dave Smith.
I'm a Developer Advocate at Google on IoT Platforms.
And I'd like to spend some time talking to you today
about some of the developer platforms
that we've been working on, specifically
in the areas of IoT, and a little bit about the Google
Assistant.
So let's dive right into this.
So computing has evolved over the years.
We've gone from mainframes, to desktops, laptops, to phones.
Every decade or so, we see sort of this major change
in computing.
And now, we're seeing computers literally embedded
into everything.
And while phones were a very large jump
over PCs in terms of the number of devices in the market,
we're expecting to see an upcoming wave of IoT devices
with things literally everywhere.
So we use the term "ubiquitous computing" to describe this.
And it's this technology that's accessible to the user
wherever they are and whenever they want it.
And today, we're going to talk about some of the platforms
that Google has been working on to support
this particular effort.
In the past, we've trained users to install
individual separate apps on every siloed platform.
But now, we have devices that are spanning
all over people's lives.
And some of these devices don't even
have screens like we would traditionally
use for a user interface in terms of a mobile application
or a desktop application.
So we need to think a little bit differently
about what computing really means
to these particular users.
And we need to take their context
into account in what we're building-- their location,
their physical activity, time of day, these types of things.
So we need to start thinking about these individual apps
as actually just individual views or unique surfaces
into a single application or a single continuous or ubiquitous
service that can service across all of these different areas.
We need to create a single seamless experience.
So what I'd like to do is walk you
through some of the developer platforms
that we have here at Google to help enable your apps to span
all of these surfaces.
And I'd like to start with Android Things.
So Android Things was recently announced.
We announced this as a developer preview back in December.
And it's Google's new platform to support development
for IoT devices.
And it's based on Android.
One of the most important features of Android Things
is the use of turnkey hardware through a System-On-Module, or
SOM approach.
And you see some of them pictured here on the slide.
The SOM contains a CPU, memory, wireless interfaces,
all of the important electronics that
are necessary with a common set of software.
And these are modules that you can buy in bulk.
They're very inexpensive.
And you can plug them into your own custom
boards, which can be manufactured at very low cost.
This is all part of our effort to democratize
hardware development for everyone,
making it fun to prototype, but also making
real possibilities for you to build
commercially viable products.
The SOM enables commercial hardware and some very
important features.
Android Things software is a variant of the Android OS
that is optimized specifically for IoT.
And we've added new APIs that are
designed to help you integrate better with custom hardware.
Beyond the device platform, it also includes secure
and manage software updates direct from Google.
These updates are managed using the Android Things console
and are verified on device for enhanced security.
We see many exciting benefits of the compute power that
is possible in a device running something like Android Things--
computer vision, audio processing, machine learning.
Computing power in these IoT devices
is increasing every year.
But at the same time, they're getting cheaper and much more
power-efficient.
TensorFlow is one of the examples
that we are seeing as one of these great new introductories
into IoT.
TensorFlow has been ported to Android.
And all kinds of hardware, such as Android Things,
also supports this.
We've built a sample that takes essentially a capture
of various images, such as dogs or cats,
or other types of breeds of animals,
and then allows the device to classify
what those images are using a pretrained TensorFlow model.
So the training is done off the device,
but the device application is able to process the image
from the camera and determine what
it is by locally running it through the pretrained
TensorFlow model.
It doesn't need any cloud communication to do this.
It does all of it locally on the device using those machine
learning APIs.
This is actually a sample that we've open sourced.
And you can take a look for more information
if you want to play around with this on your own.
We also have this sample running as a demo in the sandbox,
in that little plastic Android head.
So I encourage you to take that and play around
with it as well.
I'm not responsible for what it says when
you point it at your friends.
All right, so let's take a little minute
to talk about the Google Assistant.
The Google Assistant enables you to get things done
with the power of conversation.
It provides a new and exciting view
into your app or service for users to explore.
The Assistant is available on a wide variety of surfaces
today, from the Google Home, wearables, phones, in the car.
And we're working hard at adding it
to even more surfaces over time.
You can extend the Google Assistant
as a developer to support conversations
with your own apps using the Actions on Google Platform.
We provide a simple conversation API
to give you raw strings from the user
that you can use to then generate replies.
This is an example of what we built as a conversation action
around Google I/O. This is a very helpful API because you
don't have to do the work of parsing voice input,
dealing with text to speech.
All of that can be handled for you through the Actions API.
However, you are still responsible for interpreting
what the user has said.
And for a lot of developers, maybe you don't necessarily
want to do that yourself.
It's a fair amount of control if you need it,
but sometimes there's a better way.
So we have a great tool that is called
api.ai that does a lot of this additional work for you.
So if you haven't seen this before,
I recommend that you check it out.
api.ai uses machine learning to handle extracting entities out
of sentences for you.
It's much easier and more powerful than trying
to write these regular expressions yourself.
And it allows you to implement these conversational interfaces
with ease.
It's a graphical tool that allows
you to specify these intents and entities for the data
that you're really interested in out
of these particular conversations.
And you can see an example up here
on the slide of kind of what this looks like with a sample
that we built for a recipe recommendation app.
And essentially, what you provide
is you give the tool a list of phrases or sentences
that you expect the user to say.
And you can see that api.ai is automatically
highlighting individual entities out of those elements
that are actually interesting to your application.
So for this case, it's a recipe recommendation.
So we're looking for things like a protein,
a temperature, a type of dish.
And all of these things are just recognized automatically
by api.ai.
Now, the other really nice thing about this tool
is that you don't have to pick every single element that you
think the user might say.
Because of the machine learning element to this system,
you simply have to provide a number of samples upfront,
and then the system can interpolate and interpret
what a user might say so that you only
have to give it some initial data,
and then api.ai will be able to always do the right thing,
picking out all of the entities.
And then your back-end application
simply has to respond to that structured data.
So you no longer have to try and interpret out of a string
the information that you need.
We've also announced the Google Assistant SDK,
which enables you to embed the Google Assistant directly
into your own custom hardware projects.
We provide out-of-the-box support for Linux and Android
Things.
But the API is based on gRPC, so you could pretty much
port it to anything.
You can either use a button trigger
to trigger the Assistant, or you can use a library that we
have for hot wording support.
You can trigger it just like we do with consumer devices.
All you have to do is provide a microphone and a speaker,
and then you can use the Actions on Google
to implement additional functionality, such as Device
Control.
The Google Assistant also supports home automation
via the Smart Home system.
Device makers can easily integrate existing devices
with our Home Graph.
The Home Graph knows the state of all connected devices
so that when you ask it to dim the lights just a little bit,
it knows how to do that in an intelligent way.
The user makes queries to the Google Assistant,
and then Smart Home makes calls to your cloud service
to control those devices.
As a device maker, you don't have
to worry about handling all of that speech input,
just dealing with simple, structured requests with very
specific values.
The user speaks what they want, and Smart Home
coordinates across all of their devices inside of the home,
even across different device makers.
Firebase also has an amazing suite
of applications and services that are useful for IoT.
Real-time database, for example, makes
it easy to synchronize the state of various devices
across a mobile app and between various IoT
devices in your application.
Authentication, as another example,
enables you to associate devices with the user's account.
And with Android Things, all of these features
are even easier to integrate for IoT
because you can use the same existing Android
client libraries and SDKs right on those devices.
We also announced Cloud IoT Core back
at Google I/O. This is a fully managed service on the Google
Cloud Platform that enables you to securely connect
millions of IoT devices directly to Google Cloud.
Whether you want to connect million of devices
and scale them automatically, you
have no need to worry about provisioning infrastructure
or adding individual redundancies.
It has native support for standard protocols like MQTT,
and you can access all of your data
globally dispersed as one single system.
It's very good for enterprise use cases
where you need to do mass scale-types of provisioning.
This is sort of converse with the Firebase use
case, which works very well for individual user-type home use
cases.
You can use cloud services that are part of the cloud platform,
such as BigQuery, to analyze your massive scale data
and visualize that for internal use or for your users as well.
So that's sort of a whirlwind tour
of all the different services that we
have available for IoT and the Google Assistant.
I want you to be sure to play with all of the demos
that we have in the IoT sandbox and the Assistant sandbox.
And our team will be on hand to answer questions as well.
Immediately following this session,
I'm headed over to the IoT Office Hours
for anyone who has additional questions about any
of these platforms, and you can connect with me directly.
Later on today, we also have hands-on training
for Android Things, where you can actually
get your hands on some of these devices, and play with them,
and build an application.
And we've got another one for the Google Assistant
and Actions on Google tomorrow.
So be sure to check those out.
Oh, and one more thing.
We want to get you started on the right path
by building cool devices for IoT.
So everyone who has attended this session today
is going to go home with one of our NXP PICO Developer Kits
for Android Things.
[CHEERING AND APPLAUSE]
Make sure you grab a card on your way
out from one of the attendants, and you can pick up
your kit downstairs.
So thanks so much for your time, everyone, today.
And I hope you enjoy the rest of the conference.
[APPLAUSE]
[MUSIC PLAYING]