After provisioning your beacon, turning it on,
setting the power level et cetera,
it's time to set it up with data by registering, attaching
data, and managing the beacons with the Proximity Beacon API.
Hi, I'm Marc Wandschneider and I'm a software engineer here
at Google and I will run you through all the necessary steps
to do the above.
Not too long ago, we released details of our new beacon
platform based on the Eddystone open standard
and the Nearby Messages API.
Nearby Messages is a new API that enables your device
to react to nearby objects and micro-locations,
such as bus stops, train platforms,
or even indoor locations such as exhibits in a museum.
It makes use of a whole host of technologies including Wi-Fi,
Bluetooth, ultrasound, and most interestingly for us right now,
Bluetooth beacons powered by Eddystone.
We have some other videos talking
about beacons in general, and using beacons
with Nearby Messages.
But let's take a seconds to go over our basic scenario again.
First, you need to get some beacons.
This is usually done by talking to one of the beacon vendors
out there selling beacons compliant with the Eddystone
open format.
They'll provide the hardware and the software
needed to provision or activate these beacons.
You use the Nearby Messages API on your mobile device,
such as your Android or iOS gadget
to listen for messages when one of these beacons is seen,
and to return attached data for them.
Like for example, that this beacon is meant to be at bus
stop ABC.
Now, it's that attached to data that we're
going to be taking a closer look at in this video.
Just how exactly do I associate data with my beacons?
Well, this is done using the Proximity Beacon API, Indeed,
in addition to that, this API lets
me manage my entire fleet of beacon hardware,
register sightings, and possibly even get
some diagnostic information about the beacons.
The Proximity Beacon API was designed
to make deploying and managing beacons
easy with three key pieces of functionality in mind.
Beacon administration, beacon sighting and serving,
and beacon diagnostics.
The largest and most important of these bits of functionality
is the portion relating to managing your fleet of beacons.
It's this corner of the API that you'll
use to first register your beacons when you get them,
and then to control their lifecycle, including
their eventual retirement or decommissioning.
The beacon life cycle is roughly as follows.
First, you take your unregistered beacon
and register it.
Once registered, your beacon can switch
between active and inactive states.
Registered beacons that are active
will return information when you query the citing and serving
APIs.
Thus, when I see beacon one, two, three, four, five,
and it is active, when you ask for more information about it,
the Proximity Beacon API will tell you about it.
Inactive beacons, on the other hand,
are registered and can still be modified in our system,
but don't serve.
When an app asks if that beacon has any data associated
with it, the Proximity Beacon API will just say, nope.
Let's say you've taken a beacon out of service,
or maybe it gets lost and want to make sure it's never
accidentally reactivated.
Decommissioning deactivates the beacon permanently.
This can never be undone, and the beacon
will never serve again.
Nobody can ever register this beacon again,
and if you want to use the physical beacon hardware again,
you're going to need to use the Hardware Vendors Provisioning
app to give it a new beacon ID.
Once a beacon is registered and in the system,
we need to associate some attachment data with it
in the cloud.
These form the content of the messages
that the Nearby Messages API present to your applications
at run time.
For this, we have ways to create, fetch, and delete
attachments with our beacons.
You can put a decent amount of data
in there-- JSON, XML, BLOBs, really whatever you want.
But, stuffing massive JPG images into the database
isn't going to work.
You've got 1k to work with for each attachment.
So for larger objects, maybe splitting it up
into smaller chunks, or perhaps a link to the ultimate resource
will be the way to go.
And that's basically what the Management API is all about.
There are a few other methods for fetching things,
but it's pretty simple stuff.
You register beacons, add some attachment data to them,
and you're ready to go with Nearby Messages.
Next, we have the Serving APIs.
For those of you who will be using Nearby Messages
you won't need to worry about this.
Nearby does all of this for you.
However, for those who want to build complete beacon solutions
on your own, there's a cool method here
you want to know about.
Get info for observe beacons.
That's a mouthful.
Or just get for observed in the rest version of the API.
Basically, and this is what Nearby
is doing for you under the covers, when you see a beacon,
you query this method to see if it's a beacon you know about.
If it is, then you get information
for the beacon and attachment data for it as well.
If it's not a beacon for which there
is available registered data you can use,
the API just returns a blank response.
Finally, if you've got a large fleet,
or they're deployed remotely, we've
got yet another end-point that will make your life easier--
the Diagnostics API.
And extremely important part of managing
a large fleet of beacons is getting information on them,
including battery life, and whether the beacon
is likely to be where it's supposed to be.
The Diagnostics API will help you with all of that.
A really great way to see how to use the Proximity Beacon API is
to check out the sample applications we've put here,
at github.com/google/beacon platform.
There's one for Android and one for iOS,
and these are fantastic ways to see how to use these APIs.
You can use these samples to get familiar
with the basic flows of registering and setting up
attachment data for beacons.
You can also use these samples as a basis for your deployment
application, and integrate it with your work flows and data.
There's a ton of information available for working
with Eddystone beacons, Nearby Messages, and the Google
Proximity Beacon API.
First, check out the docs for the Proximity Beacon
at developers.googl e.com/beacon/proximity.
Or just visit developers.google.com/beacons
for more on the broader picture.
As we mentioned before, our API samples are
at github.com/google/beacon platform.
And you can also learn more about Eddystone itself
at github.com/google/eddystone.
We've also made a couple of other videos
on beacons, which of course, are great viewing.
So with this knowledge combined with what
I talked about in the using Nearby with beacons video,
you've now got a complete story on how to use beacons
with Nearby Messages.
I hope you find it as exciting and interesting as we do.
We can't wait to see all the cool new stuff
you're going to come up with this technology.
[MUSIC PLAYING]