What's New in watchOS 3

Session 208 WWDC 2016

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.

[ Music ]

[ Applause ]

All right.

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 behavior automatically.

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 on NSProcessInfo.

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, improvements.

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 [ Applause ]

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.

[ Applause ]

Apple, Inc. AAPL
1 Infinite Loop Cupertino CA 95014 US