Google Beacon Platform & Eddystone: Proximity API Explained

[00:00:00]PETER LEWIS: All right, hello.

[00:00:03]Hello, everybody, welcome.

[00:00:07]My name is Peter, and I am the product manager for Eddystone and the Google beacon platform, and I am uncomfortably excited today to be talking to you about location and proximity superpowers.

[00:00:23]So, we're going to cover a whole bunch of stuff, and it's going to be awesome.

[00:00:28]So, if my clicker works-- oh, that was the laser pointer.

[00:00:34]We're going to get in some code, but before we do that, I want to introduce you to my dog.

[00:00:39]This is Oscar.

[00:00:41]Oscar is like my sidekick, I suppose, if we're talking about superpowers.

[00:00:46]He is a four-year-old Papillon, and one of my favorite things is taking him up to Hampstead Heath in London, near where I live, and taking him for a long walk amongst all the trees and the bushes.

[00:01:01]And while I'm walking along, he's constantly sniffing, discovering all the interesting smells, like, is this an important bush?

[00:01:09]Is this is a stick I should be playing with?

[00:01:11]He has a fantastic sense of all of the important places and objects that are around him, and this session is about to make your users' devices almost as awesome as Oscar.

[00:01:30]So, today I want to talk to you a bit about a few location-based experiences.

[00:01:38]So, here are a few examples from within Google Apps.

[00:01:42]In the Photos app, I can search for photos I took when I was at Google in New York.

[00:01:48]There's timeline for helping users to rediscover places that they've been to, and the experiences they've had there.

[00:01:55]And there's sort of popular times for one of my favorite restaurants here in London, that reminds me it's been two months.

[00:02:01]I should probably go again.

[00:02:04]And these kind of location-based experiences make apps really compelling.

[00:02:10]If you can provide services to your users that take account of the important places and objects to them, then you can build engagements and be much more successful.

[00:02:23]So, all of these are powered by a complicated array of sensors in the user's device, but the experience at the end of it is really simple.

[00:02:33]They use Wi-Fi, cell tower location, GPS to produce this kind of thing.

[00:02:40]But what we want to do is to provide really simple APIs to be able to develop your own apps, and even in cases where you don't have an app, on top of this platform.

[00:02:51]So, today we will cover Eddystone.

[00:02:54]Eddystone is the open beacon format from Google, and we want to make it so that the beacons you have on your desk actually become useful quite quickly.

[00:03:06]We're then going to talk about how to link your beacons with the Cloud, so that you can think of them much more like Cloud objects.

[00:03:14]That is, we're going to talk about attachments, subscriptions, and nearby-- and sharing those beacons with others, so that this physical widget gets all of the power of the Cloud.

[00:03:26]And then last up, we're going to talk about something new that was announced an hour ago in stage one, I think.

[00:03:33]Powering experiences at your venue through Google.

[00:03:36]So, even in the case where you don't have your app installed, how can you use beacons to bring awesome experiences to your users?

[00:03:44]So, what is the technology we're going to use?

[00:03:46]Well, we're going to use beacons.

[00:03:49]And, in fact, beacons are not new at all.

[00:03:55]If I can advance the slide-- yes, beacons are not new.

[00:04:02]So, here's an example of a beacon, a lighthouse, and all of the components of the Google beacon platform are similar to a lighthouse and a ship at sea.

[00:04:12]So, you have the lighthouse itself.

[00:04:14]That's the Eddystone beacon.

[00:04:16]It just sits there and it broadcasts an identifier to the world.

[00:04:21]Meanwhile, out at sea, the captain of the ship has got the telescope.

[00:04:25]They're looking out for all of the beacons that are around the coastlines of countries.

[00:04:31]That's like the Nearby API in Android and the CocoaPod for iOS.

[00:04:36]But just sighting the beacon is not that useful.

[00:04:40]You're also going to need a chart with all of the beacons mapped out on it to look up exactly where you are, and that chart is provided by the Proximity Beacon API, which is the Cloud service that you can use to register beacons with Google.

[00:04:57]So, we're going to go through each of those parts, but with the Google beacon platform rather than lighthouses and ships.

[00:05:04]And by the end of the session you're going to be able to build awesome beacon powered experiences in your app, and also we're going to give you some ideas for how to use beacons in the cases where your app is not yet on the user's device.

[00:05:19]So, what is a BLE beacon?

[00:05:21]Well, I have one just here.

[00:05:25]They're sort of simple, typically battery-powered devices that you can use to mark important places and objects in the world.

[00:05:34]You stick them on the object and they just broadcast an identifier.

[00:05:38]They do exactly one thing.

[00:05:41]The identifier that they broadcast is only 31 bytes long, and by the time you've gotten rid of all the headers there's not really very much space left for content.

[00:05:50]So, by placing an abstract identifier in your beacon that you mark, you make devices that come near it aware of that place.

[00:06:01]Because beacons only accept connections from devices when they're being configured, they're really good for deploying in public places.

[00:06:08]So, you don't want users' devices to have to connect to these Bluetooth things all the time.

[00:06:13]You just want your user's device to have a great idea about the important places and objects around it.

[00:06:20]So, beacons have been around for a little while, and Bluetooth beacons have as well.

[00:06:24]And in the olden days we sort of had this model, that you would deploy a beacon, it would talk to a particular app, and it would probably power a particular feature in that app.

[00:06:38]We're taking a slightly different approach with Eddystone and the Google beacon platform.

[00:06:46]We're interested in having one beacon or many beacons with many uses.

[00:06:51]So, you deploy your infrastructure once, and then you can reuse it multiple times in different apps from different people, all coming to your venue.

[00:07:03]So, what is step one?

[00:07:06]Well, we've provided an app for you to get started.

[00:07:09]It's called Beacon Tools, available on the Play Store and the iOS app store.

[00:07:14]Download this app and you'll be able to talk to beacons.

[00:07:20]It's an app that allows you to register beacons with the Google Cloud platform.

[00:07:24]So, it sits between the beacon and Proximity Beacon API.

[00:07:31]You can register beacons that have a number of different frame types.

[00:07:34]This is the complete Eddystone specification.

[00:07:38]There are four frame types in Eddystone.

[00:07:40]There's Eddystone UID, which is the abstract marker for a particular place.

[00:07:46]For cases where you're interested in controlling who has access to your beacon signal, there's Eddystone EID, and I'll talk a bit about that in a minute.

[00:07:56]Then the third frame type is a telemetry frame.

[00:07:58]This reports on the beacon's battery level, which makes it easy to monitor a fleet of beacons once they're deployed in the wild.

[00:08:06]And then finally, you can put a pretty tiny URL into the beacon frame itself, and Eddystone URL forms the backbone of the physical web.

[00:08:17]So, I want to talk a bit more about Eddystone EID, and you can see I've made a beacon with a pretty colorful center just here.

[00:08:24]What that represents is that the beacon frame itself is continuously changing.

[00:08:31]So, I have a beacon, it's broadcasting one frame, and then a few minutes later it's broadcasting a different frame.

[00:08:37]And your beacon generates those frames based upon a cryptographic key that's stored within the beacon itself.

[00:08:44]That key is also shared with another service, which is able to resolve a sighting of that particular beacon to a stable ID so that you can make use of it in your app.

[00:08:55]It's particularly good for cases where you want to control who has access to the beacon signal that you're deploying, and the good news is that all of our APIs supports UID and EID transparently.

[00:09:09]So, you don't have to bother thinking about EID.

[00:09:12]You can deploy mixed networks of UID and EID beacons, and still talk to them both through the same Nearby API and Android.

[00:09:24]So, that's Eddystone.

[00:09:26]We've got static identifiers which are, in a sense, the simplest way to get started, and we've got ephemeral identifiers, and these are the ones that are ideal for controlling your beacon signal.

[00:09:38]But that's just the beacon itself.

[00:09:40]The real power comes from the Cloud service that you associate, where you put that beacon, and that is fronted by Proximity Beacon API.

[00:09:52]Proximity Beacon API is an API that fronts Google's beacon registry that allows you to register beacons, associate information with them, and add attachments which can be used by your own app.

[00:10:05]So, a beacon object looks a bit like this.

[00:10:09]I've represented it as a box, and within the box we've got three attachments represented by these three colors.

[00:10:18]So, let's have a look at the beacon registry entry itself.

[00:10:22]Here is the list of properties that you can associate with a beacon.

[00:10:26]First up, you can assign the beacon a description.

[00:10:31]The description of the beacon is your human readable name for that particular beacon, and we'll talk a bit about how you can search for things like that later.

[00:10:40]You can add properties to a beacon, so it's sometimes useful to remember the transmit power that you associate it with a particular beacon or some other properties that are relevant to your particular venue.

[00:10:53]Then, the next set of objects is to do with place and location.

[00:10:58]When you register a beacon with Google, you can associate a place ID with it which goes into the heart of Google's location infrastructure.

[00:11:07]So, all of the out of place functionality that I showed earlier just gets better when you have a beacon signal registered with a place ID.

[00:11:17]As well as that, beacons enable new kinds of precise locations.

[00:11:22]So, in particular, you can associate an indoor level with a beacon, which makes it much easier for your app to detect which level a user is on in a building.

[00:11:32]This last field, expected stability, allows you to distinguish between beacons that you deploy in a static place, sort of marking important places in a building, and those, perhaps, that are on a bus, or a food truck, or move around.

[00:11:48]Finally, we have the ephemeral ID registration object, which keeps all of the records necessary to support Eddystone EID.

[00:11:57]So, if you're using Eddystone EID beacons, you'll need to talk to this part of the API.

[00:12:02]And finally, when you provision a beacon using the Eddystone gap service, there is a key that you can use to unlock that particular hardware, and we can store that for you to make beacon administration easier later on.

[00:12:18]So, what's next?

[00:12:19]We have a beacon, we have a Cloud service.

[00:12:21]On a user's device in the middle we have the Nearby API.

[00:12:25]And I want to take you on a sort of brief tour of the Nearby API, showing how you can use it to fetch attachments back to your beacon, back to your user's device.

[00:12:39]So, this is what you need to put in your manifest.

[00:12:41]It's important that you put your API key to talk to the Nearby Messages API.

[00:12:49]You also need a service running in the background for if you want background beacon scanning, and you can also put intent filters in your manifest as well.

[00:12:59]And that's something you should do because of a reason I'm going to tell you about in a bit.

[00:13:05]Once you've connected to Google Play services in your Android activity, then this is the meat of your subscription.

[00:13:14]So, this is where you tell the nearby API that, I'm interested in attachments of a particular name space and a particular type.

[00:13:22]It's that line under set filter.

[00:13:25]So, what happens next?

[00:13:28]Well, the Nearby API takes all of the information that you've given it and it does beacon scanning for you.

[00:13:36]Notice that you don't have to care about the actual bytes that the beacon is broadcasting.

[00:13:42]You've created a subscription to a Cloud object, and Nearby is going to hide all of the sophistication in the background.

[00:13:48]So, Nearby goes out looking for beacons.

[00:13:52]and when it does beacon scans it shared them across all apps that have active subscriptions.

[00:13:58]As well as that, when the Android platform does scans they're also shared to Nearby.

[00:14:03]So, you get a lot more scans for a lot less battery use.

[00:14:08]When Nearby comes out and finds a beacon, it will query the Proximity Beacon API to say, hey, I found this beacon.

[00:14:16]I don't know what it means.

[00:14:18]And Proximity Beacon API will return attachments that were the ones that you had subscribed to.

[00:14:26]So, let's take a look at what an attachment looks like.

[00:14:31]They're pretty simple objects.

[00:14:32]They have these two important fields.

[00:14:35]The first one is the name space type for the project.

[00:14:38]The name space is owned by your project, so you have a name space for your particular developer console project.

[00:14:46]After that you can put a type for each attachment.

[00:14:50]That could be platforms at a station, or it could be different types of vehicle.

[00:14:55]It can be anything you want.

[00:14:57]And then the second field is the data that you associate with that beacon under that name space type.

[00:15:04]So, this is where you put the information that you actually want to get back in your app when your user sights that particular beacon.

[00:15:11]If you're calling the API directly, remember to base 64 encode it, but our tools take care of that for you.

[00:15:19]So, Nearby had this subscription to a particular name space and type.

[00:15:24]Proximity Beacon API decided if there were any attachments on the beacon that had been seen that correlated with your particular subscription, and then those attachments are returned to your app so that it can behave as you would expect.

[00:15:42]Launched this morning, if you don't care about integrating with APIs and so on, you can use the beacon dashboard.

[00:15:51]This is a web dashboard that actually uses the JavaScript client library to Proximity Beacon API, and allows you to visualize all of your beacons and edit the information associated with them.

[00:16:04]So, for a particular beacon object, registering a beacon just becomes filling in a bunch of fields on here.

[00:16:14]We think this is really cool.

[00:16:15]You can also add attachments.

[00:16:17]Here's an example of an attachment that I added this morning, and you can see it's a simple matter of filling in two fields on a web dashboard.

[00:16:26]You now have a registered beacon and an attachment associated with it.

[00:16:32]So, where have we come?

[00:16:33]Well, we started with a beacon.

[00:16:36]We provisioned it using beacon tools, which you can get from the Play Store all the iOS app store.

[00:16:44]Then, we associated that beacon in the Cloud with Proximity Beacon API, which allowed us to create this beacon object and add attachments to it.

[00:16:54]If you didn't want to call the API, we have the dashboard.

[00:16:57]And then down in the bottom right, we've got the model of what happens when a user's device comes across a beacon.

[00:17:04]And as I said earlier, it doesn't matter whether you're using Eddystone UID or Eddystone EID, Nearby will behave exactly the same.

[00:17:12]You just create a subscription to the name space and type of attachment that you're interested in.

[00:17:21]So, I mentioned earlier that there are good reasons for registering beacons in the Cloud, and one of those is that you can create a beacon network and share it with many different developers.

[00:17:35]So, launched recently, Proximity Beacon API is one of the first APIs to use Google Cloud's identity and access management roles, giving fine grained control over which developers can make use of your beacon network.

[00:17:54]So, here we go.

[00:17:58]Here is a picture of the Google Cloud Platform developer console, and their Identity and Access Management, you can add members to your project.

[00:18:07]So, these are adding developers who can do things with resources that are in your project.

[00:18:11]Things like compute engine instances or data store, and so on.

[00:18:15]And Proximity Beacon API is one of these, so once you've enabled the API you can add a developer and choose from the roles that we have available.

[00:18:28]So, these are the new roles, and I want to just go through them a bit and tell you about what they allow developers to do with your beacon network.

[00:18:39]So, first up is BeaconEditor.

[00:18:41]If you grant a developer this role, then they're able to add beacons to your project.

[00:18:48]It's important if, for example, the person who's writing the app is not the person who's going and sticking up the beacon.

[00:18:54]The person who's going and sticking up the beacon, you want them to be able to register beacons to your project but you don't want them to be able to fire up compute engine instances.

[00:19:02]So, BeaconEditor is a role that you can assign to a user or to a group to enable them to add beacons to your project.

[00:19:10]And it's important to note that beacon IDs are universally unique in Google's beacon registry.

[00:19:17]So, once a beacon has been registered it can't be registered by a different project.

[00:19:23]Next up we have AttachmentEditor.

[00:19:26]Now, I mentioned earlier that attachments have a name spaces associated with them and the name space belongs to your project.

[00:19:35]AttachmentEditor allows you to say, I want this developer to be able to add attachments to my beacons in my name space.

[00:19:45]So, that means that they can add attachments that can interact with your app, and they can do this in combination with BeaconEditor.

[00:19:53]So, they can register a beacon to your project and they can add attachments to it as well without all of the other permissions that come as a result of being an owner of a project.

[00:20:05]Finally, is AttachmentPublisher.

[00:20:09]What this allows, you can say, that developer can create attachments in their own name space on my beacons.

[00:20:17]So, I have a beacon network, and I can say, my friend, here, I want them to be able to add attachments in their own name space that will talk to their own app on my beacons.

[00:20:32]And these roles and these new sharing paradigms allow a bunch of useful things.

[00:20:38]So, here we have three different phones, belonging to three different users, with three different active nearby subscriptions, all talking to the same beacon.

[00:20:49]And these attachments can be added by different developers.

[00:20:52]So, there's a lot of flexibility in the way that you can use a beacon network.

[00:21:00]You don't any longer just deploy one beacon for one app.

[00:21:05]We have one beacon with many uses.

[00:21:10]Great, yeah, it's awesome.

[00:21:12][APPLAUSE] Right, so, interacting with Google products.

[00:21:23]Sometimes people come to me and they say, Peter, PM for beacons.

[00:21:28]This is fantastic, but my app has to be everywhere in order for it to be useful.

[00:21:33]This is not true.

[00:21:36]So, what I want to talk about now is how you can take your beacons and interact with Google products at the heart of Android, like Nearby Notifications.

[00:21:48]So, Nearby Notifications was announced just an hour ago and is available in the next version of Google Play services, But what I want to tell you today is how you can register beacons today and add attachments that will interact with Nearby Notifications.

[00:22:09]Nearby Notifications allows you to prompt notifications in Android in three different categories of cases.

[00:22:19]You can associate web URLs with your beacons.

[00:22:23]So, you've registered a beacon.

[00:22:24]You can associate a URL with it.

[00:22:28]You can associate app intents.

[00:22:29]So, remember earlier I said, make sure that you've put intents in your Android manifest.

[00:22:34]You can point to those intents with a beacon attachment, and if the user doesn't have your app installed, you can have a URL that's the fallback.

[00:22:42]So, if I have your app installed, I come near the beacon, it intents into your app.

[00:22:47]If I don't have your app installed it says, here is a website.

[00:22:52]And then last up, there's a direct app installs.

[00:22:56]So, this is an early program, and we're holding it behind the white list at the moment.

[00:23:01]So, if you would like to apply to have your app white listed for direct app installs associated with beacons, then you can go to developers.googl e.com/nearby/notifications and it will tell you how to get started.

[00:23:18]So, let's have a look at what these things look like.

[00:23:21]Here are three examples of Nearby Notifications.

[00:23:26]Right up at the top we've got an app for a coffee shop, and this passed our white list because of a particular reason, and that was that a user could take an action if they had the app installed right at that place.

[00:23:42]So, it's very much about, is a user going to install your app and then do something immediately with it?

[00:23:49]That's a really good candidate for Nearby Notifications.

[00:23:53]In the second case, this is an example where, at Kim's Vitamins, a web URL was associated with the beacon that pointed to a particular website managed by that business.

[00:24:08]And then at the bottom we've got everybody's favorite example in San Francisco, apparently, paying for parking.

[00:24:16]Finding an app where you can pay for parking and actually use it right then to pay for the place where you've just parked is another good candidate for Nearby Notifications.

[00:24:28]So, let's go back to the beacon object and have a look at it.

[00:24:32]We have three attachments on this beacon.

[00:24:34]The bottom two are attachments that you added.

[00:24:37]So, they're things that interact with your app.

[00:24:39]Maybe you've got some kind of beacon functionality baked in.

[00:24:43]But we want to focus on the top one, just here, and what you'll notice about it is that the name space for this particular attachment is not your project.

[00:24:52]This is com.Google.nearby, a name space that is reserved for Nearby Notifications.

[00:24:59]Any developer can write attachments in this name space, but they can only attach those attachments to their own beacons.

[00:25:10]So, if you register a beacon with Google, you can write into this name space.

[00:25:15]If this other person registers a beacon with Google, I cannot write into that name space on that beacon.

[00:25:22]So, you have to own a beacon in order to take part with Nearby Notifications.

[00:25:29]So, let's have a look.

[00:25:31]We have the Nearby attachment, and you can see that it's in this com.Google.nearby name space.

[00:25:38]In the type field we've put en-debug.

[00:25:43]So, en is a language code.

[00:25:45]We only want to show your Nearby Notifications to users who have set the default language on their device to the notification that you want to show.

[00:25:54]And then in the data we've got some Nearby attachment data.

[00:25:58]This is exactly the same pattern that you would build if you were putting functionality in your own app.

[00:26:05]So, what does this data look like?

[00:26:07]Well, it's just some JSON with a title, a description, and a URL.

[00:26:14]you can create this dead easy, and the URL is the part that's interesting.

[00:26:20]So, there's a little bit of subtlety here.

[00:26:22]I'm going to go through it quite carefully.

[00:26:24]So, here are the three different categories of Nearby Notification that I mentioned before.

[00:26:33]Up at the top, this is the URL that we would associate with a direct app install.

[00:26:38]You can see that it points to a particular package in the Android Play store.

[00:26:44]In the middle, this is a URL that we would associate with if the user has the app installed, intent into it.

[00:26:51]If they don't have the app installed, then we'll fall back to a website.

[00:26:55]And then at the bottom you've got the simple case, just a web URL.

[00:27:00]The gotcha with that one is that you have to remember it's HTTPS, so HTTP URLS are filtered out.

[00:27:13]Right, that is the end of the content for this talk.

[00:27:19]I'm now going to do a demo for your entertainment and amusement, that is possibly the most dangerous demo that's ever been done.

[00:27:27]I'm going to use two different kinds of radio.

[00:27:31]I'm going to use an unreleased product.

[00:27:34]I'm going to use a product that we launched this afternoon, and I'm going to use two different devices.

[00:27:41]So, before your very eyes, here is my beacon.

[00:27:47]It's broadcasting, and in Beacon Tools I can search for it just like this.

[00:27:55]Excellent, it's shown up.

[00:27:57]So, I provisioned this beacon earlier, and there it is.

[00:28:00]I'm going to register it.

[00:28:03]I'm glad that nobody got there before me.

[00:28:06]If somebody else had registered that beacon, this would not have worked.

[00:28:12]Right, what I just did was, I took this beacon that was broadcasting at Eddystone UID and I registered it with my project.

[00:28:22]You can see that I tested this maybe seven times before I got in here.

[00:28:27]And this is the beacon dashboard that I was talking about earlier.

[00:28:30]So, if I refresh it, fingers crossed, here is my new beacon that I just registered right now.

[00:28:39]By the way, if this all works I want you guys to give a cheer that is loud enough to wake the engineers in London who made it.

[00:28:48]So, I can associate some information with my beacon.

[00:28:52]So, the I/O beacon.

[00:28:56]This is the human readable label that I want to associate with the beacon so I can find it later.

[00:29:02]I can associate a place with it.

[00:29:04]So, I can put it in Amphitheater Parkway, and this will plug into the rest of Google's location infrastructure, as I mentioned before.

[00:29:14]And this particular beacon, this is not going to move around, so I'm going to make it stable.

[00:29:19]Now, here are some sort of useful administrative labels for me.

[00:29:24]So, I can in things like the TX power, the transmit power of this particular beacon.

[00:29:30]So, maybe it's broadcasting at minus 20 DBM.

[00:29:35]Great, so, I've now registered at this beacon with Google, I've added a description so that I can find it again, and I've put a place ID with it as well.

[00:29:49]Next up, I can add attachments to it.

[00:29:52]So, here is the name space that's associated with my project, and it is very easy to add an attachment.

[00:30:03]There we go, I just press plus, and I now have a beacon registered with an attachment to it.

[00:30:08]So, I can use Nearby messages to get that attachment back in my app.

[00:30:14]Tomorrow, probably, you should go to the code lab's tent, and there is a code lab specifically on Nearby subscriptions from Nearby messages.

[00:30:22]So, make sure you go there in order to get some of these attachments back, and we've created a zoo of attachments around I/O, so if you do it on your own phone you'll be able to collect all of those animals.

[00:30:34]Finally is this category, Nearby Notifications.

[00:30:38]So, I said earlier that you have this JSON object that you can construct, but what we decided was that we could make it easier than that.

[00:30:46]So, we just have a web form that you can fill in.

[00:30:50]I can put a title in here, I can put a description for the notification that I want to show.

[00:30:57]Can somebody give me a random word?

[00:31:00]AUDIENCE: Bacon!

[00:31:01]PETER LEWIS: Bacon, perfect-- the bacon.

[00:31:05]This is going to prove that I'm doing this live.

[00:31:08]I'm going to put it in English, and how about we just point to www.google.com.

[00:31:18]Great, so I can check all of the details I put, and I can create the attachment like that.

[00:31:26]So, what this has done is created a Nearby Notifications attachment on that beacon that I registered on the stage, live in front of all of you.

[00:31:34]Let's go back to the device over here.

[00:31:37]And on this particular phone, I have Nearby Notifications running.

[00:31:43]So, when I screen on and I pull down the notification shade, and I screen on again, I'm going to see a couple of websites that are not the ones that I was thinking of.

[00:32:05]Third time lucky, boo, it looks like it might not work.

[00:32:15]So, what's happening is it actually does a beacon scan when the screen comes on, and I'm hoping that it can see this beacon that is sitting right next to it.

[00:32:22]There we go, the bacon.

[00:32:25][APPLAUSE] I select that, and google.com appears.

[00:32:38]So, we registered the beacon, we added a Nearby Notifications attachment to it, and that took us straight to that link when the user's device came.

[00:32:49]So, that is the Google beacon platform.

[00:32:53]One beacon, many uses.

[00:32:56][MUSIC PLAYING]