watchOS 3 brings together notifications, complications, and the new Dock to keep your apps glanceable and responsive. Find out about the new additions to watchOS to create stunning visuals and learn about new snapshotting APIs to ensure your app is up to date when people glance at their wrist. Take a tour of watchOS 3 enhancements with us and find out which sessions you won't want to miss throughout the week.
Thanks very much.
So I'm excited to tell you all about what's new in watchOS 3.
Now, of course we've really focused in watchOS 3
on optimizing the performance of the system,
and there's been a ton of changes in this area
to make sure that all of your apps run as fast as possible.
We've also spent a bunch of time optimizing navigation,
and that's really in service of optimizing performance,
because the faster we can get a user into your app,
the faster they can start using it,
and the faster we can get them to be able
to drop their wrist again, and move on to the next thing.
Now in addition to all these enhancements to the system,
we've also spent a bunch of time optimizing different things
in all of our apps as well.
Now all of those enhancements really revolve
around three key qualities for watch apps that I promise you
and warn you you will continue to hear a lot
about throughout the rest of the watch sessions [laughter].
So the first one is making sure that they're glanceable.
Now, being a glanceable watch app does mean a bunch
of different things, and it starts right at the watch face,
because having a complication
on the watch face gives you a really great opportunity
to present the most important bit of information from your app
to the user at just a glance.
Of course, in watchOS 2, we also had glances.
In watchOS 3, that functionality has merged into the dock,
which is a great place to present glanceable information
as well, because it's really quick to get to from anywhere
on the system and gives you an easy way to get an overview
and summary of the best and most important information
from your apps.
So in addition to being glanceable, we wanted all
of our apps to be actionable, and actionable can mean a number
of different things as well.
It might mean that you take the action on the watch itself.
You've seen that we've redesigned a bunch
of our built-in apps to make sure
that the most common actions that we take are easy to access
with just a couple of taps.
The Workout app, you can now get into really quickly
and start a workout with a single tap.
The timer app now raises the most common timers
that you'll want to set right to the top level
so that once you're in it,
with just one tap you can start really common timers.
And so this kind of pattern is something
that we definitely would encourage you to think about,
figure out the things that are the most common actions
in your apps, and brings them up to the top level,
and make them really easy to get to.
Of course, being actionable doesn't necessarily mean
that you have to be able to take the action on the watch itself.
It might just mean presenting content that your users want
to act on, even if they're not ultimately going
to take an action on the watch.
Again, complications are a great place to do this
and the new dock as well,
presenting the most important information
that users can then go and act on outside in the real world.
And then the third quality, of course, is responsiveness,
making sure that your apps are up to date and ready to respond
as soon as the users want them.
And a bunch of the performance work that we've done
in watchOS 3 is really geared towards this aspect
of making all of the apps as responsive as possible.
By keeping them in memory,
which we'll talk a little bit more about, and making sure
that they can resume really fast, we can make sure
that they're as responsive as they can be.
And the best thing that you can do to help make sure
that your apps remain responsive is
to do adopt the new background app refresh technologies,
which we'll talk about in a little bit, to make sure
that your apps already have the content that they need
to display to the user when they're ready to be used.
So thinking about apps, of course, we can go back
to a full-screen view of an app.
That's what a lot of people think
about when they first think of an app,
but that may not be the most common place for users
to interact with your apps on Apple Watch,
because to keep interaction short,
there's some other really great interfaces that are even faster
to use for a lot of the most common things that we do.
Of course, there's complications, which start right
on the watch face, giving you info you want.
And notifications, which can pop up info
at the most relevant time.
And notifications on Apple Watch are great, because you get
to run code to populate the notification with content
and custom UI to present just the interface you want.
And of course, with the new dock in watchOS 3, you can now get
to your apps with just the tap of the side button,
no matter where you are in the system.
Now, apps in the doc are great,
because they're immediately responsive.
As soon as you tap on one, it comes full-screen,
and you can interact with it right away
without having to wait at all.
The dock is great, not just for directly interacting with apps,
but also for consuming information.
Glances in watchOS 2, that functionality has now moved
into the dock in watchOS 3, so you can quickly slide
through a view of the information
from your favorite apps really quickly
to get a high-level overview of the info from all of those apps.
So the dock combines the best of what glance has provided
with quick access to your apps
to provide even more functionality.
So for something like reminders, it's really great for both.
You can get a quick overview of the things that you need to do,
and you can tap in to immediately bring it full screen
and make it interactive, so you can check them off.
For other kinds of apps, you may just have functionality.
For example, the Workout app,
we've brought those most common workouts that you want
to perform right to the top level, so you can tap on them,
tap in to bring the app full screen, and with one tap,
be starting your workouts.
But the dock is also, as we said,
great for just viewing information.
So an app like the Activity app is really great
for just getting a summary of the information from this app.
And with the Activity rings basically taking
up the full screen, you can get a great high-level summary
that's really glanceable and really easy to digest.
The Activity app itself has also been redesigned when you go
into it to simplify the navigation in the app.
So where in watchOS 2 it was four tabs arranged horizontally,
each of which could scroll vertically, in watchOS 3,
there's just one view, vertically scrolling,
that has the summary of the activity at the top
and some of the detail below.
So it's really easy and even faster
to get the information you want out of this app.
Now, we want to keep interactions with the watch
as short as possible, and so this new navigation model
and the enhancements to make apps responsive
and live right away really helped to make sure
that the most tasks that you want to perform
on Apple Watch can be accomplished
in just a couple of seconds.
And so as you're thinking about how you want to update your app
for Apple Watch, for watchOS 3, or if you don't have one yet
and you're contemplating what to put in it,
I would definitely encourage you to spend a bunch
of time thinking about how to shorten your interactions.
Two seconds is obviously a very short time, but striving
for that can really help you to figure out the best
to design your apps to make them as great an experience
on Apple Watch as possible.
So with the rest of our time, I want to talk about four things.
The first is Background App Refresh.
As I mentioned, this is a huge enhancement in watchOS 3
that is Background App Refresh that is really critical
for building responsive watch apps, so we're going
to spend a bunch of time talking about that.
Then I also wanted to talk a little bit
about simplifying navigation, because we've done a lot of work
to simplify navigation on the system,
but the next step is simplifying navigation
within your apps as well.
And so we've got some ideas of how we've done that ourselves
that we'll share, and there's also plenty of ways
that I'm sure you can come up with to simplify navigation
in your own apps as well.
Then we'll spend some time talking
about expanding API availability.
We've brought some great frameworks
from our platforms, the watch SDK.
We've got some brand new ones,
and we've got some great enhancements
to our existing frameworks as well, so we'll talk
about a bunch of the high-level points in there
and give you some great pointers to other sessions
that have even more detail.
And then we'll end by talking about discoverability
and configuration, because building your great app is just
the first step.
You also need to get it in front of users
and configure it on their watch.
So let's get started with Background App Refresh.
Background App Refresh is a critical part
of building a responsive app for Apple Watch.
And before you've even done any work,
Background App Refresh is already working for you.
You don't actually need to adopt any APIs
to get some of its benefits.
So the first thing is that all
of the users favorite apps are kept in memory.
They're launched in the background, and then suspended,
and kept there ready to go so that as soon as the user wants
to get them, it's just a short resume away, and we don't have
to wait for a full application launch.
Now, I mentioned that that applies
to the user's favorite apps,
and I do mean something pretty specific by that.
This is all of the apps that are
on the user's current watch face, so any complication
on the current watch face that has an app,
that app is one of their favorites.
And all of the apps that the user has placed
in their dock are their favorite apps.
These apps are the ones that they're kept in memory and ready
to go as soon as they're needed.
They're the ones that the user has the easiest access to,
because they're either a tap away on the watch face
or just an easy scroll through the dock away.
And so we want them to be there, ready to go,
and as responsive as possible.
And as I mentioned, you don't have to do anything to get this.
Even your existing watchOS 2 apps will get this
But of course, there are APIs involved
with Background App Refresh that you can adopt
to make your apps even more responsive once they become
to the foreground and making sure that they're
up to date and ready to go.
And so the first things that you can do
with this are obviously updating your complication
and updating your app.
Keeping your app up to date means updating these things.
But there's another important aspect to it as well
that might be immediately obvious,
and that is that you want to also update your snapshot.
Now you might be wondering what do I mean by a snapshot,
because you haven't written code for snapshots.
And this applies specifically to apps that are in the dock.
Now, when the dock first comes to the foreground,
all of the apps that are in the dock are sitting in memory,
but they're suspended and not currently running.
So what's displayed as soon
as the dock comes forward is a snapshot of what the app looked
like in its last state.
Once the user settles on one of the apps in the dock,
it will be resumed and become live,
even while it's still shrunk down in the dock.
But in the meantime, we're displaying a snapshot
of what was there in the last state.
So it's important that that snapshot remain up to date
as well, so that you're displaying old information
until the app gets resumed.
Even more importantly, if I quickly scroll through the dock
and don't land on any of the apps,
they're not being unsuspended
and resumed the entire time while I'm scrolling.
So we're just scrolling through the set
of the last snapshots that were displayed.
So you definitely want to make sure that these snapshots are
up to date and displaying current information,
and the Background App Refresh APIs make it really easy
to do this.
Starting off, there's actually some automatic behaviors
that you get from the system before you even have
to add any new requests to update things.
Now, the first one is probably pretty obvious.
If you've actually gone into the app and used it,
then the user has probably seen some new information
or performed some action in there and will want
to update the snapshot that will be displayed the next time.
So when the user leaves your app,
the system will automatically schedule a snapshot update
to happen on your behalf.
Now, it's really easy to handle this,
because there's one new Background App Refresh method
that all of the background refresh activity goes through.
So it's just a simple method that you add
on your WatchKit extension delegate,
and it'll get called back when any
of these refresh activities occur.
And so the first one is the automatic snapshot that happens
when your app is suspended.
But there's also other times that users may see information
from your app, where you'll want to update the snapshot so often
that we just do it automatically.
And the other one, which may not be as obvious,
is after a notification has been viewed.
So if the user looks at a long look of your notification,
they may have seen some new information that informs them
of some new state in your app.
If they then go into the dock
and see something else displayed there and it's out of date,
that would probably be surprising.
So when your notification is dismissed,
the system will automatically schedule a background snapshot
task for you in that case as well
so that you can update your snapshot,
update your complication, and make sure that everything stays
up to date and in sync.
Of course, there are also times that you'll want
to schedule updates on your behalf.
You know your users and you know your data, so there are times
where you actually just want
to proactively be updating your content,
and there's really two ways to do this.
The first is going to be about complications.
The question then becomes, what do you put in your snapshot?
So the first and most obvious thing to put
in your snapshot is just whatever the content
of your app normally is, that way it looks up to date
and it's showing exactly what you would want
when a user goes into the app.
But you might also decide that you want
to provide some custom information that is different
so that it looks nicer in the dock and is easier
to glance at and digest.
For example, the Dexcom G5 mobile app, with that app,
the most important thing that I would care
about is my current blood glucose level.
So if I look at it in the dock,
I'll see that highlighted really big in the center of the screen.
But when I actually go into the app, I might care
about more detail than just the current reading.
So as I bring the app full screen, it can transition
and show more information when I'm actually in the app,
displaying, in this case, a historical graph
of more information going back in time.
Now, you don't necessarily have to display different information
in the dock snapshot, and a very common thing would be
to not do that, and just have it be the content of your app.
But you do have a lot of flexibility here,
so if it makes sense in your app to display something different
in the dock snapshot, just make sure that the transition
as you go into the app is still smooth
and not really jarring when it happens.
Okay, so in addition to these automatic snapshot tasks
and keeping your snapshot up to date, you may also want
to periodically be able to update the data behind your app
in the background, and there's a few different ways
that you would go about doing that.
Now, you might just be interested in going
out to the Internet to fetch some new data, and you can do
that with a NSURLSession and Watch Connectivity,
but there's plenty of other ways as well, and the first one
to focus on is complication updates.
Now, complications are visible right on the watch face,
so it's even more important that they stay
as up to date as possible.
So there's a kind of update that is available just to apps
that are on the current watch face,
and that's the silent complication push update.
Now, these types of updates existed in watchOS 2,
but they were a little bit difficult to use,
because you couldn't be guaranteed
of how many you would get over the course of the day,
so it was a little difficult to plan for how many you would use
and when you would send them.
In watchOS 3, there's been a big enhancement
for complication push updates, and we now guarantee
that over the course of the day,
each app on the watch face can get 50 push updates.
This is great, because it gives you the opportunity to plan
for how you want to use them over the course of the day.
So for example, let's say we took a stocks app.
If we just did the most naïve thing
and distributed our 50 updates over the full day,
that would give us about one every 30 minutes.
And that's not too bad, but we could do a lot better if we took
into account a little bit information about the data
that we were displaying and about our user behavior.
For example, let's say that we know
that our user generally sleeps between midnight and 6:00 a.m.
If that's the case, then we really don't need
to update during that period of time,
and we can distribute the updates we would have used then
through the rest of the day.
So that'll increase our update frequency
to once every 20 minutes, which is a pretty big improvement
with only a small amount of effort.
But of course, it we know a little bit more
about the data itself and could take that into account,
then we might be able to do even better than that.
So let's say that we knew that our stocks were only
from the New York Stock Exchange.
In that case, we'd only need to update between 9:00 a.m.
and 4:00 p.m. when the exchange is open,
and that would increase our frequency
to once every eight-and-a-half minutes.
So now, obviously, this specific example will not apply
to the vast majority of your apps, but the idea
in general definitely can.
Taking into account a little bit of extra information
that you have about your user behavior and the kinds of data
that you're displaying can give you a lot of opportunity
to even further enhance the experience
when using your app on the watch face.
Okay, but those are just for complications displayed
on the current watch face.
Now, if you have an app that's either not
on the current watch face but in the dock,
or an app on the current watch face
where push updates maybe don't make the most sense.
There are other ways to update your data as well.
In these cases, you'll probably want
to do some periodic scheduled updates in the background
over the course of the day.
So there's another Background App Refresh API
that will let you schedule the next time that you'd
like to run, and each time you run, there's a number
of different things that you could choose to do.
You could start some data downloads using NSURLSession
or Watch Connectivity.
Or you could just load new data out of your database
on the watch if you already have all the information present.
But in addition to that, you'll also have the ability
to schedule the next update session.
So it's not a fixed period that you have to decide on upfront.
Each time you run, you have the opportunity
to choose the next best time to run after it
so that you can optimize for your data style
and when you know that it will be updated.
Now, at a minimum, you'll be guaranteed
that your application can run at least once an hour,
but there are some other things can enable you
to run even more frequently than that.
So the first would be if your application is backed
by a complication.
So if a complication is on the current watch face,
then your app will have the ability
to update more frequently than once an hour.
But even if you're not on the current watch face,
you may be able to run more frequently than this as well.
So the total number of updates that are available is fixed
for all of the apps that are currently in the dock.
So if the dock is full, and all ten apps are present,
then each of the apps in there will be able
to update once an hour.
But if the user hasn't filled their dock,
and there are fewer apps in there,
the updates that would have been given to the ones that aren't
in use can be distributed amongst the rest.
So in that case, you could end up having more
than one update per hour.
Of course, as you're designed your app, it's probably easiest
to plan for once an hour,
because that's the minimum guarantee.
But just keep in mind that it may be possible
that you could be running more frequently than that,
depending on these other situations.
So there's one last thing that I wanted to mention
about complication pushes.
Complication pushes, when you think of a push, the first thing
that may come to mind is a push that's initiated from a server,
and that's definitely one option.
You can start a complication silent push update
from the server.
But what you may not have thought of is
that you can also start complication pushes
from your iPhone app running on your iPhone as well.
The push update API is actually part
of the Watch Connectivity framework.
So if your app on your iPhone is running for some other reason,
either the user is directly using it
or it's using some Background App Refresh API on the phone,
it can initiate a complication push update to the watch
to update the UI on your complication.
So even if you don't have a server
that has the knowledge necessary to do pushing,
you may actually still be able to take advantage of this
to keep your watch face up to date.
So just something to keep in mind
as you're designing your complications
and your refresh strategies for your apps.
So that's just a quick summary of Background App Refresh
and how all this stuff works, and I really want to reemphasize
that it's really a critical part of building responsive apps.
So no matter what kind of app it is that you're building
for Apple Watch, I'd strongly encourage you to check
out the Keeping Your Watch Up to Date session to learn more
about Background App Refresh and how you can use it
to keep your apps live, responsive, and up to date.
So next, let's talk about navigation enhancements.
Now, as I've mentioned, we've already done a whole bunch
of work to optimize navigation on Apple Watch itself.
So the system is already really fast to get into your apps.
The next step is optimizing navigation within your apps
so that it's really fast to get to the information
and actions that the users want.
Now, there's one common pattern in particular
that I want to start with.
There's many apps that have a hierarchical organization
to their data.
For example, there's a top-level view that has a bunch
of information on a list of top-level items.
In this case, I've written an app to keep track of all
of the beverages that I've consumed today.
Now, if you want information on any one particular item,
you can tap on it, and it'll slide into a detail page.
So here we can see that I've had three cups
of coffee so far today.
In watchOS 2, if you wanted to get more information about one
of those other items, you would tap the Back button,
find the other item, and slide into that one.
Now, that may not seem like a lot of overhead,
but given how short we're trying to keep these interactions,
that additional time just moving back
and forth can actually really add up pretty quickly.
So in watchOS 3, you'll find that there's a lot of apps
that have this kind of pattern, where we've now moved
to a new style of navigation for them,
where you can just use your finger or the digital crown
to quickly scroll and page between each of those items
without having to do the back and forth navigation transition.
So if you look at, for example, the Stocks app
or the Weather app, they've been redesigned
to enable this ok interaction, and we wanted
to make it really easy for you
to adopt this in your apps as well.
So the WatchKit table interface control now has an option
to enable this vertical paging mode when you're navigated
into a detail view, and it's really easy to opt into it.
There's just a couple of things you have to do.
First, obviously you can enable the option on your table.
But then you also have to make sure
that in your storyboard you're using segues
to represent the transitions from your table
into the detail views.
By doing that, you give WatchKit all the information it needs
to be able to pre-generate the views above and below,
and place them in a vertical paging interface
so that it can move between them.
So not too much adoption, and it's really easy.
The only other thing to keep in mind is that to get the behavior
to match this, you also need to make sure that the design
of your detail views fits all the content
of the detail view onto a single screen.
If the actual detail view itself is also scrollable,
then that scrolling in the detail view will take precedence
over the outer paging interface.
So you definitely want to focus
on simplifying the views for the detail items.
You'll find, again, in the Stocks and Weather apps
that these views now, while
in watchOS 2 they scrolled vertically and had a bunch
of information in them, are now just single-page interfaces,
so that they can easily transition like this.
Okay, so we've gotten our users into our app really fast.
We've optimized the background refresh so that our data is
up to date, and we've optimized navigation
within our app as well.
The last part of ensuring that individual interactions
with Apple Watch are short is to get our users back
out of our app as quickly as we can.
And of course, on Apple Watch,
that means giving them the confidence
that they can drop their wrists.
So there's a number of ways that you might go about doing this.
Let's just take one example here.
Let's say that I've got an app where I'm purchasing my dinner.
When I tap this Buy button, I'm going to go
and do some network activity to a server, which is going
to perform some actions to decide whether
or not I can actually make this purchase.
Now, that might take a while.
So my first inclination might be
to display an indeterminate progress indicator to the user,
letting them know that something's happening,
but I'm not sure how long it's going to take.
Now, unfortunately, that means that they're going to sit there
with their arm up, waiting for something to happen
until this task finishes.
But if I'm really confident that the vast majority
of the time the task is going to succeed,
I'm not actually getting anything
by having them sit there and wait for it.
So instead, you could decide
that you could present some confirmation interface
that really gives them the confidence
that you're taking care of the task without having
to wait for it to occur.
So in this case, I've just said, "Got it!
We're working on your order."
Once they read that, they have the confidence they can drop
their wrist, and you can continue the operation
in the background for up
to 30 seconds using the background activity APIs
Generally, everything works, and so you don't have
to get their attention back.
Now, of course, sometimes something may go wrong.
Maybe your server's not reachable,
or there's some other issue.
In that case, watchOS 3 includes a brand new User Notification
framework that lets you schedule local notifications
on the watch itself, and that's a great way,
during this background time to be able
to get the user's attention back,
let them know something went wrong, and have them be able
to fix it really easily.
So in this case, let's say that, unfortunately,
my order of chicken was not available.
I can pop up a notification, letting them know that happened.
Of course, because notifications can include actions,
I can have some buttons right there with options
to resolve the issue, or I can get them quickly back
into my app so that they can fix it themselves in the full app.
The User Notification framework is a great way to do this,
but of course, it's not just for letting users know about issues.
Local notifications can be a great enhancement
for many different kinds of apps.
And the great thing about the User Notification framework
in watchOS 3 is that it can work
when the watch is entirely standalone,
because it's scheduling the notifications
on the watch itself.
But now you do have a choice to make with notifications,
because you can either use the notification framework directly
on the watch to schedule your notifications,
or you can continue doing what you were doing in watchOS 2,
sending a message back to your phone app
with Watch Connectivity and scheduling a notification there.
These are actually both totally valid things to do,
and it depends a little bit
on what you're trying to accomplish.
The important distinction is
where the notifications will appear.
So if you send a message back to your phone app
with Watch Connectivity, and schedule the notification there,
the notification will appear on both your phone and your watch,
and you'll be notified on whichever device you're using.
So if you were using your phone, it would appear there.
If you're using your watch, it would notify you there.
If you use the new User Notification framework
on the watch itself, that notification will only appear
on the watch and will not propagate back to the phone.
Now, that actually might be exactly what you want.
There are many cases where you really do want
to schedule a notification that would only ever show
up on the watch at all, and that's now easy and possible
with the new User Notification framework.
But even better is you-- [clapping].
Thanks. But even better,
you don't necessarily have to make the choice.
If your goal is that you want the notification to appear
in the right spot, no matter what,
even if the user leaves their phone behind, you could choose
to schedule it in both places using Watch Connectivity
to send a message back to your phone app
and scheduling it there, or maybe it was just data that was
in your cloud service, so you just,
by default, schedule it there.
And also scheduling it with the new User Notification framework
on the watch.
If you do that, as long
as you've used the same notification identifier both
times that you schedule it,
watchOS will de-duplicate those notifications
so that you only have it appear on the watch once, not twice.
So some great new stuff with the User Notification framework.
Now, while individual interactions
with the watch are short, there may be some apps that you want
to use multiple times over a longer period.
For example, here I've got my chicken pot pie recipe,
and I'm going to the store to pick
up all the items I need to cook it.
Now, in watchOS 3, each time I raise my wrist, I'm brought back
to the last app that I was used
to that I can really quickly see the items that I still need
to pick up, and check off the ones that I've already gotten.
I'll be brought back to that last app for up
to eight minutes after I last used it.
This is great, because it lets you design apps
that have this kind of interaction pattern,
where you use it for many brief interactions,
but over a longer period of time.
This is the new user default for all users in watchOS 3,
so it's to plan for this
and build your apps and design around it.
These are just a few of the ways that we've been thinking
about improving app interactions in watchOS 3,
and there's a ton of other ways.
I'd encourage you to check out the Quick Interaction Techniques
for watchOS session, where you can get more detail on a bunch
of these kinds of ideas and a bunch of others as well.
So that's navigation.
Now let's talk a little bit more
about the enhanced API availability in watchOS 3.
As I mentioned earlier, we've brought a bunch
of great frameworks from some of our other platforms.
We've got some great new frameworks.
For example, the User Notification framework,
and we've also added a whole bunch of APIs to many
of the frameworks that are already on Apple Watch.
So let's start with one we've already talked about,
Background App Refresh.
I wanted to bring it up again just
to reinforce how important I feel like this stuff is.
And the three key things that it gives you are the ability
to schedule updates, perform complication push updates
with that guarantee of 50 over the course of the day,
and make sure that your snapshot and your doc is up to date
and in sync with your notifications
and your complications.
Again, definitely check out the Keeping Your Watch App
Up to Date session as well for far more information about this.
Now, fitness apps have a unique need for staying up to date,
because during a workout it's really important
that they be displaying current information and up
to date throughout the workout.
So the big enhancement for workout apps this year is that,
in watchOS 3, they will continue to run in the background
for the entire duration of your workout session.
This gives you the opportunity to monitor workout progress,
watch-- use all of the sensor API to keep track
of where things are going,
and notify the user using notifications,
or haptics, or sounds.
And of course, we've enhanced the access to the heart rate
and accelerometer so they now provide continuous values
throughout the entire workout, instead of batching those values
in increments that are delivered in chunks.
So it makes it really easy to keep track of the current state
of the workout the entire time and stay up to date.
Because they're running, you can also update your UI,
which makes sure that as the user raises their wrist,
they can very quickly see the correct current state
of the workout without any extra delays.
It's a really, really big year, actually, for fitness apps,
and there's an entire session just about these and a number
of other enhancements for these apps, so definitely check
out Building Great Workout Apps to learn all about how
to make your workout apps really amazing in watchOS 3.
But there is one bit I want to focus
on a little bit more here first,
and that's the background runtime.
Because there's a bit of a balance to be had here,
you absolutely want to have your app
up to date during the workout.
But you also want to make sure
that you're preserving a great experience
for users throughout the rest of their day by being careful
to preserve their battery life.
And a big components of that is making sure
that you're keeping track of the amount of CPU
that you're using during the workout.
And Xcode now has a great interface to help you keep track
of that, both how much you're using at an instant
and the amount that you're using in aggregate
over a period of time.
So for the first part, there's a clear view,
right up here near the top, that will tell you the amount of CPU
that you're currently using, and then down in the center,
there's a great graph that shows you some historical information
about the CPU usage over time.
Now, you can clearly see here the spikes,
where we've been doing a bunch of work.
But in yellow, in the center there,
you can see that we've got a rolling average of the amount
of CPU that's being consumed by our app in the background
over some period of time.
Now this part is the one I want to focus on,
and it's the most important,
because while your workout app is running in the background,
there's a cap imposed on the total amount
of average CPU usage that it can be using
over this period of time.
And you want to stay below that cap to make sure
that your app continues to run in the background,
and preserves the battery life of the user
over the whole rest of the day.
So that cap here is indicated clearly by Xcode
by the red dotted line, and you can watch
as your average approaches it, and make sure
that you stay below it.
So there's, again, a ton of information
about the background fitness workout experience,
Definitely go check out more of that, but this is the one thing
that you really should keep in mind about CPU usage
as you're developing these apps.
So in addition to the sensor enhancements for these kinds
of apps with making heart rate
and accelerometer continuously available,
we've also got a bunch of great new hardware access APIs.
So crown events give you raw access to rotation events
from the digital crown.
In watchOS 2, your apps could use the crown for scrolling
within your interface or for picking items from a list
with the picker control.
But of course, we saw many innovative uses
of the picker control for other interesting things,
and we realize that everybody, obviously, wants raw access
to digital crown events.
So that's now available, and you can use it for all kinds
of other interactions in your apps as well.
Now just gesture recognizers really make it easy
to add touch interactions to your apps.
There's a whole bunch
of single-finger interactions available, like tap, swipe, pan,
long-press, and it's really easy to add these to all
of your different WatchKit interface elements
so that you can have different parts
of your app screen respond in different ways.
And of course, we've also made the gyroscope accessible now
in addition to the accelerometer,
so you've got a ton of information about the motion
of the device available for all kinds of interesting use cases.
Again, the quick-- oop.
Go for it [clapping].
Again, the quick interaction technique session has a bunch
of information on this and other use cases.
I do want to give you a couple examples of some
of the cool things that you can do with this though.
So first off, you can see here Acorns has made use of the crown
to let you quickly scrub through information
on a graph showing you the historical information
about your account.
So in a single simple interface, you can quickly move
through a lot of information, all visible on one screen.
Here we have Sweat with Kayla, which has taken advantage
of the swipe gestures to be able to quickly move
between these different workouts
and choose just the one that they want.
Of course, you can also use the digital crown to move
between them, and with just a tap, you can activate the one
that you're interested in.
Now you'll notice that there's some kind
of interesting visuals here
that are adding a little liveliness to the interface.
And to help make that possible in all your apps,
we've got some great graphics and media frameworks
that we've bought over to Apple Watch.
SpriteKit and SceneKit make it really easy to add both 2D
and 3D graphics and animations
to enhance different parts of your apps.
And of course you can use them
in your long look notifications interfaces as well
to make your notifications really interesting and lively.
And because we've been talking a lot
about simplifying navigation, we also wanted to make it possible
to play back video in line
in your application interfaces as well.
In watchOS 2, we introduced video playback in watchOS apps,
but for it to work there, it actually took you
out into a separate full-screen interface,
where you watched a video
and then dismissed it when you were done.
With inline video playback, you don't have
to leave your application's primary interface at all,
and you can play it back right there.
Even better, it supports autoplay,
so as soon as the video becomes visible on screen,
it will start playing and can pause when it goes off.
If you have multiple short videos on a scrolling list,
the one on screen at any one time will automatically play
while all the others pause.
It's a really great way
to add some really short interaction videos
into your apps.
And because apps in the dock are live while they're in the dock,
the autoplay feature can actually even work there.
So if you have a quick video that needs to be displayed
as you scroll through the dock, when users come to rest
on your app, that video can start playing right in line
without even taking your app full screen.
So some really great enhancements
for video in watchOS 3.
SpriteKit and SceneKit can be used for all kinds of things.
Here you can see a Seven Minute Workout has taken great
advantage of SceneKit to bring a lot of the visuals that they had
on their iPhone app to Apple Watch as well.
So you can see exactly the workout that you want to perform
and get a lot of clarity on how you should do it.
So in addition to adding a lot of interesting visuals
to your apps, SpriteKit and SceneKit are obviously great
for short interaction games.
We've also bought GameKit to Apple Watch and watchOS 3,
which makes it really easy for you
to add turn-based gaming to your watch apps.
Because GameKit's turn-based gaming APIs are built on top
of NSURLSession, they can work even
if your phone is not present,
when your watch is near known WiFi networks.
The GameKit achievement APIs can also be used
to earn achievements on Apple Watch, which can then be viewed
on iPhone, or iPad, or your other platforms
where you've got your game.
And of course, with AV foundation, it's not really easy
to play sounds out of the watch speaker.
Now, gaming on Apple Watch is really just getting started,
and with some of these new frameworks, I'm really excited
to see what kinds of things you guys come up with
for short interaction games on the watch.
To give you just one idea of how this can result
in a really interesting game,
I want to show you a quick video here of a new game
that WoGa is developing called Fish Time
that lets us go fishing at short intervals on our watch.
So with just a swipe, I can go cast my line,
and I can use the digital crown to drop my lure
down to just the right depth where I want.
Now, I could leave it there for a while and wait, or I can tap
to go fishing right now.
Looks like I got a bite.
Now you can use the crown again to reel it in,
but now I actually-- I didn't catch it.
That'll probably make the fish a little happier,
although our fisherman might not be so happy about it.
So really cool how you can add some really interesting graphics
and get some great animations using SpriteKit on Apple Watch.
Really, really looking forward to see what kinds
of things you guys do with this.
So next up, I want to mention CloudKit.
We've brought CloudKit to the watchOS SDK,
including the new CK Share APIs, which make it really easy
to share data between different users.
Again, because it's built on an NSURLSession, it's really easy
for it to work, even when your phone isn't present.
There's a whole session on CloudKit with What's New
in CloudKit that I definitely encourage you to check out.
And finally, we've got Apple Pay.
Apple Watch is a great way to pay for physical goods
in stores, and of course with Apple Pay on Apple Watch,
you can now offer physical goods for purchase within your apps
with just a double tap of the side button.
Now, there's many different ways that you might go
about using this, but for example, you might choose
to offer for purchase the most common item that I buy every day
for lunch, so that I can make that order really easily
at lunchtime every day, right from my watch.
There's a lot of ways that you can offer physical goods
for sale within your watch using Apple Pay.
So that's just some of the APIs
that are a part of the watchOS 3 SDK.
There's a bunch of new s tuff in there.
Definitely go check it all out.
I'd like to end by talking about discoverability
and configuration, because, again,
building a great watch app is just the first step.
You also want to make sure that it's really easy for users
to discover it and get it installed.
So the first enhancement for this comes
in the iOS 10 Apple Watch app.
There's a brand new watch face gallery, which displays all
of the watch faces that users can add on their watch.
And even better, right at the top of the screen,
it includes an entire section dedicated just to all
of your apps, and getting in here is really easy
and requires just a couple of steps.
So first off, you have to adopt a new ClockKit API.
You already had an API in watchOS 2
for specifying a template complication view.
This API has been in enhanced in watchOS 3
to not just return a string for your complication data,
but actually the localization key
to get localized strings for all languages.
This is important, because the second step is
to build a complication bundle.
You use the-- you do this using the simulator.
You run your app, and build a complication bundle,
and this creates a static representation
of your complication template
that you can then include in your iPhone app.
It's really easy to do, and by doing it,
it gets you into this gallery section so that you can show up.
We need the static representation,
because that way we can display your complication in line
in a watch face here, even if your app isn't
yet installed on the watch.
So just a couple of steps, and the payoff is really big.
You'll be right here in the gallery.
The gallery is the first thing that new watch owners see
after they've paired, so it's definitely a place
that you'll want to be.
In addition to the gallery, we've also made it a lot easier
to customize watch faces and get your apps onto them.
It was always possible to configure your watch faces
on the Apple Watch, and in iOS 10, the Apple Watch app
on iPhone now includes an entire face configuration UI as well.
Obviously, they're kept in sync, so any changes you make
in one will be reflected in the other, and it's not really easy
on your phone to select all the complications that you'd
like on all your watch faces on Apple Watch.
And with quick watch face switching,
there's now even more reason to have a complication,
because more users will have more watch faces,
and your apps can be right on them.
So then the last part of configuration is the dock,
and obviously, you can configure the dock
in the Apple Watch app on your iPhone.
It's really easy to add and remove apps from the dock,
and reorder them right there.
But even more importantly, you can do it on the watch itself.
And there's one feature in particular
that makes it really easy to find
that you can add apps into the dock.
The last app that you used is always displayed in the dock,
even if you hadn't chosen to put it there.
So if a user installs your app and doesn't even yet know
that they can add things to the dock,
they go to the home screen, they find the icon and launch it.
The next time they go to the dock, they'll see your app
in there with a big button under it that says Keep In Dock,
which, with one tab, will add it
to their permanent list of apps in the dock.
So it's really easy to discover that you can add them there,
and also easy to add them there from the watch itself.
So again, you're going to hear a lot about building glanceable,
actionable, and responsive apps,
and I really do encourage you to keep that in mind.
There's a great design session that Michael gave
that you can go check out for Designing Great Apple Watch
Experiences, where he'll talk even more
about all these things, so definitely check that out.
And the responsive part of this is so important
that there are really two sessions focused just on this,
with Architecting for Performance on watchOS 3,
and Keeping Your Watch App Up to Date.
These are two that you'll definitely want to check
out to get all the benefits of Background App Refresh
and making sure that your apps are up to date
and responsive for watchOS 3.
And there's a whole bunch
of other sessions throughout the week that have a lot
of information, many focused on Apple Watch, and a whole bunch
that just include Apple Watch information.
Thanks so much for coming and joining, and I can't wait
to see what you do with Apple Watch.
Enjoy the rest of the week.
Looking for something specific? Enter a topic above and jump straight to the good stuff.
An error occurred when submitting your query. Please check your Internet connection and try again.