[MUSIC PLAYING]
Hi.
My name is Fred Chung, part of
Android Developer Relations.
Today we're going to talk about
Bluetooth Low Energy.
In Android 4.3, we are adding
built-in platform support for
Bluetooth LE.
The new Nexus 7 and the Nexus
4 are the first two Nexus
devices that are going to be
Bluetooth-smart ready, making
them capable of communicating
with the many Bluetooth smart
peripherals on the
market today.
I'm going to do a sample
app walkthrough today.
But before doing that, I'd like
to walk you through some
technical concepts of Bluetooth
Low Energy so that
you can make sense out
of the API objects.
As its name implies, Bluetooth
Low Energy uses less energy as
compared with Bluetooth
Classic.
It is not uncommon to have
Bluetooth Low Energy devices
that last for weeks, if not
years, before needing to
recharge or replacing
the battery.
The protocol itself is optimized
for a small burst of
data exchange, which is ideal
for applications such as
sensors, remote controllers,
so on and so forth.
In contrast, Bluetooth Classic
quite often is involved in
high bandwidth applications
such as audio streaming.
Now let's have a look at how
information is structured in
BLE applications.
BLE is based on a specification
called general
attribute profile, or GATT, It
governs sending and receiving
of short pieces of data
known as attributes.
The Android app can be either a
GATT client or a GATT server
depending on the application.
The GATT server can support
a collection of services.
You can think of services as
different features offered by
the device.
Each service is uniquely
identified by a UUID
referenceable by your
application.
Under each service, there
could be a collection of
characteristics which you can
perform read or write
operations depending
on the BTLE profile
you're working with.
To put things in perspective,
let's have a look at the heart
rate measurement profile
which is one of
the standard profiles.
The heart rate sensor
is the GATT server.
The Android app in this diagram
is the GATT client.
The GATT server hosted on the
heart rate sensor device
offers a number of services.
Under the service, there's
a collection of GATT
characteristics.
There's one for providing heart
rate measurements which
you can receive notification
on when that indicates the
location of the sensor which
you can read from.
Now that we have some basic
understanding on Bluetooth Low
Energy technology, let's have
a look at some code.
Let's first take a look at
the Android manifest.
There's a new feature called
android.hardware.bluetoothle.
You declare it if your
application would only work on
devices that has that feature.
You can omit it if your
application would work on a
device without that feature
so that you can optionally
disable the Bluetooth
Low Energy
features within your app.
Now the debugging
session is up.
I'm going to go ahead
and click Scan.
So I've put some break
points here.
What it's trying to
do is to call a
startLeScan method call.
And as you can see in the API
documentation, a lot of the
BLE operation methods are
asynchronous in nature.
You have to specify a callback
such that when interesting
events happen, in this case,
when devices are discovered,
the callback methods
are invoked.
So I'm going to let this
breakpoint go.
As you can see in the
app, it's able to
find a couple of devices.
Let's go ahead and click on
Heart Rate Sensor, which
corresponds to the test kit that
I'm trying to test with.
So let's go ahead
and click on it.
Now it brings you to another
activity which is bound to a
background service.
And I've put a breakpoint
in the service.
What it's trying to do is to
connect to the GATT server
that's hosted on this device by
invoking this method called
connectGatt.
Just like the previous example,
since all APIs that
have to do with BLEs are
asynchronous in nature, you
have to pass another
callback here.
Now that we've connected to the
GATT server, it's trying
to invoke this method called
discoverServices by trying to
discover the available
GATT services
hosted on this device.
Let's go ahead and release
the breakpoint.
And now the callback on
services discovered is
invoked, meaning the app has
found the services that are
available on the device.
The app's going to iterate
through the collection of
services found and display
on the UI, as seen here.
Since this is a heart rate
sensor, we're going to do some
heart rate measurements.
Let's go ahead and locate the
heart rate service, expand it,
and you'll see Heart Rate
Measurement characteristic.
Let's go ahead and
click on it.
What happens is that since it
knows that the characteristic
supports notification, it
tries to enable the
notification.
So let's go ahead and release
this breakpoint.
Now, as soon as it begins
getting heart rate updates
reading, you'll get this
callback on characteristic
change indicating that you are
receiving a notification.
So we're going to go ahead and
release the breakpoint.
As you can see on the screen
here, we are receiving heart
rate measurement readings in
this very, very tiny text.
I don't know if you
can see it.
But it's updating with heart
rate measurement notifications
receiving from the
peripherals.
Now, I want to illustrate
a very important point.
And that is whenever you are
done with a particular
Bluetooth LE connection with a
peripheral, you should really
call this close method so
that the stack can do
it's clean up properly.
That's it for the walkthrough.
If you want to learn more, do
check out the Bluetooth Low
Energy developer guide
on d.android.com.
Thank you for watching.
