Architecting for Performance on watchOS 3€¦ · Redistribution or public display not permitted without written permission from Apple. App Frameworks #WWDC16 ... Agenda 2-Second

© 2016 Apple Inc. All rights reserved. Redistribution or public display not permitted without written permission from Apple.

App Frameworks #WWDC16

Session 227

Architecting for Performance on watchOS 3

Tyler McAtee watchOS EngineerTodd Grooms watchOS Engineer

Agenda

Agenda

2-Second Tasks

Agenda

2-Second TasksDesign

Agenda

2-Second TasksDesignCase Study

2-Second Tasks

What are they?2-Second Tasks


Purposeful


PurposefulQuick, short, simple


PurposefulQuick, short, simpleMeasured from beginning to end

Examples2-Second Tasks


Check a notification


Check a notificationSet a timer


Check a notificationSet a timerStart a workout

2-Second TasksImprovements

2-Second Tasks

Complications for all

Improvements

2-Second Tasks

Complications for allDock

Improvements

2-Second Tasks

Complications for allDock

Improvements

2-Second Tasks

2-Second Tasks

ComplicationApp

ComplicationApp

Dock App

Dock App

Dock App

Dock App

ComplicationApp

ComplicationApp Dock App

Dock App

Dock AppDock App

ComplicationApp


Dock App

Dock AppDock App

Dock App

Dock App

Dock App

Dock App

Dock App Dock App

ComplicationApp


Dock App

Dock AppDock App

Dock App

Dock App

Dock App

Dock App

Dock App Dock App

ComplicationApp

ComplicationApp

ComplicationApp

ComplicationApp


Dock App

Dock AppDock App

Dock App

Dock App

Dock App

Dock App

Dock App Dock App

ComplicationApp

ComplicationApp

ComplicationApp

System App

ProcessProcess

Mail/Calendar

Sync

Workout Session

Process Process

Process

Background Task

Process

ProcessProcess

Process

Process

Process

LimitMemory

LimitMemory

WatchKit applications have a fixed memory limit

LimitMemory

WatchKit applications have a fixed memory limitShould be nowhere near the limit

LimitMemory

WatchKit applications have a fixed memory limitShould be nowhere near the limitCurrent limit is 30MB

StrategiesMemory

StrategiesMemory

Use appropriately sized images

StrategiesMemory

Use appropriately sized imagesUse appropriately sized data sets

StrategiesMemory

Use appropriately sized imagesUse appropriately sized data setsUse lightweight APIs

StrategiesMemory

Use appropriately sized imagesUse appropriately sized data setsUse lightweight APIsDon't keep around things you no longer need

ComplicationApp

ComplicationApp

Dock App

Dock App

Dock App

Dock App

Key Path in watchOS 3Resume Time

ComplicationApp

ComplicationApp

Dock App

Dock App

Dock App

Dock App

Key Path in watchOS 3Resume Time

Resuming often in the DockResume Time

Resuming often in the DockResume Time

Lifecycle extension delegate methodsResume Time


applicationDidFinishLaunching


applicationDidFinishLaunchingapplicationDidBecomeActive


applicationDidFinishLaunchingapplicationDidBecomeActiveapplicationWillResignActive


applicationDidFinishLaunchingapplicationDidBecomeActiveapplicationWillResignActiveapplicationDidEnterBackground


applicationDidFinishLaunchingapplicationDidBecomeActiveapplicationWillResignActiveapplicationDidEnterBackgroundapplicationWillEnterForeground

Lifecycle interface controller methodsResume Time


awakeWithContext:


awakeWithContext:willActivate


awakeWithContext:willActivatedidAppear






awakeWithContext:willActivatedidAppearwillDisappear


awakeWithContext:willActivatedidAppearwillDisappeardidDeactivate





applicationDidFinishLaunching

applicationDidBecomeActive

awakeWithContext:

willActivate

didAppear

applicationWillResignActive

willDisappear

didDeactivate

applicationDidEnterBackground

Keeping Your Watch App Up to Date Mission Thursday 9:00AM

Snapshot!


Snapshot!

willActivate

didAppear


Snapshot!

handleBackgroundTasks:


Snapshot!

willDisappear

didDeactivate

applicationWillEnterForeground

willActivate

didAppear

applicationDidBecomeActive

TipsResume Time

Already Set!!

TipsResume Time

Use discretion when updating WKInterface objects

Already Set!!

TipsResume Time


Already Set!!

WatchKitExtension

WatchKit UI

TipsResume Time


Already Set!!

WatchKitExtension

WatchKit UI

TipsResume Time


Already Set!!

TipsResume Time

TipsResume Time

WKInterfaceTable is not a UITableView

TipsResume Time


TipsResume Time


TipsResume Time


TipsResume Time


TipsResume Time

Keep WKInterfaceTable size down


TipsResume Time


Avoid reloading a WKInterfaceTable when possible


TipsResume Time




TipsResume Time




Design

Design

Design

Glanceable UI

Design

Glanceable UIFocused purpose

Design

Glanceable UIFocused purposeNavigation

Design


Design


Design


Design


Quick Interaction Techniques for watchOS Presidio Wednesday 11:00AM

contextForSegue:withIdentifier:inTable:

contextForSegue:withIdentifier:inTable:

awakeWithContext

willActivate

didAppear

awakeWithContext

awakeWithContext

didDeactivatewillActivate

didDeactivate

willActivate

didDeactivate

willDisappear

willActivate

didDeactivate

didAppear

willDisappear

didDeactivate

A Watch App built with WatchKitCase Study: Stocks

Case study outlineStocks


2-second tasks


2-second tasksBackground refresh


2-second tasksBackground refreshResume time optimizations

2-Second Tasks

2-second tasksStocks

Complication Chart/Detail List View

Complication2-Second Tasks

Fastest way to check your favorite stock’s current priceData is in sync between complication and app

Complication2-Second Tasks

Fastest way to check your favorite stock’s current priceData is in sync between complication and app


Navigation flow2-Second Tasks

watchOS 2


watchOS 2


watchOS 2


watchOS 2

watchOS 2


watchOS 2


watchOS 3

watchOS 2


watchOS 3

In the Dock2-Second Tasks

In the Dock2-Second Tasks

2-second tasks recapStocks


Consistent data between complication and app


Consistent data between complication and appSimplified our design


Consistent data between complication and appSimplified our designImplemented new Vertical Detail Paging API

Background Refresh

Background refreshStocks


How often do we need to update?


How often do we need to update?What data do we need to fetch to keep our app fresh?

Refresh cadenceBackground Refresh

12:00 AM 12:00 AM12:00 PM


Request data every 15 minutes

12:00 AM 12:00 AM12:00 PM


Request data every 15 minutesMarkets are open for a period of time throughout the day

12:00 AM 12:00 AM12:00 PM


Request data every 15 minutesMarkets are open for a period of time throughout the day

12:00 AM 12:00 AM12:00 PM


Request data every 15 minutesMarkets are open for a period of time throughout the dayThere are days when the market is not open

12:00 AM 12:00 AM12:00 PM

Decide next refresh dateBackground Refresh


Enumerate through list of stocks


Enumerate through list of stocksIf markets are all closed, use earliest market open time


Enumerate through list of stocksIf markets are all closed, use earliest market open timeElse at least one market is open, use regular 15 minute cadence

// Schedule background refresh

func scheduleBackgroundRefresh(preferredDate: NSDate?) {

if let preferredDate = preferredDate {

let completion: (NSError?) -> Void = { error in

// Handle error if needed

}

WKExtension.shared().scheduleBackgroundRefresh(

withPreferredDate: preferredDate,

userInfo: nil,

scheduledCompletion: completion

)

}

}}






}



userInfo: nil,


)

}

}}






}



userInfo: nil,


)

}

}}






}



userInfo: nil,


)

}

}}

// Helper method to grab preferred refresh date

func nextPreferredRefreshDate() -> NSDate? {

guard let earliestNextOpenDateInStocks = self.earliestNextOpenDateInStocks() else {

return nil

}

let nextRegularRefreshDate = NSDate(timeIntervalSinceNow: RefreshTimeInterval)

return earliestNextOpenDateInStocks.laterDate(nextRegularRefreshDate)

}




return nil

}



}




return nil

}



}




return nil

}



}




return nil

}



}

// Calculate the “next open date” for a user’s list of stocks

func earliestNextOpenDateInStocks() -> NSDate? {

let stocks = self.stocksManager.stocks

guard stocks.count > 0 else {

return nil

}

var earliestNextOpenDate = NSDate.distantFuture()

for stock in stocks {

guard !stock.marketIsOpen else {

// If market is open, return distantPast

return NSDate.distantPast()

}

if let nextMarketOpenDate = stock.nextMarketOpenDate {

earliestNextOpenDate = nextMarketOpenDate.earlierDate(earliestNextOpenDate)

}

}

return earliestNextOpenDate

}





return nil

}






}



}

}


}





return nil

}






}



}

}


}





return nil

}






}



}

}


}





return nil

}






}



}

}


}





return nil

}






}



}

}


}





return nil

}






}



}

}


}

Schedule multiple background requestsBackground Refresh


Endpoint A updates the app Endpoint B updates the complication


Schedule background refresh timeOn receipt• Submit Endpoint A request• Submit Endpoint B request• Schedule future background refresh time

// WKExtensionDelegate Handle Background Tasks

func handle(_ backgroundTasks: Set<WKRefreshBackgroundTask>) {

for task in backgroundTasks {

switch task {

case let appRefreshTask as WKApplicationRefreshBackgroundTask:

self.scheduleDataUpdateRequest()

self.scheduleBackgroundRefresh(preferredDate: self.nextPreferredRefreshDate())

appRefreshTask.setTaskCompleted()

case let urlSessionTask as WKURLSessionRefreshBackgroundTask:

self.storeURLSessionTask(urlSessionTask: urlSessionTask)

default:

task.setTaskCompleted()

}

}

}




switch task {







default:


}

}

}




switch task {







default:


}

}

}




switch task {







default:


}

}

}




switch task {







default:


}

}

}




switch task {







default:


}

}

}




switch task {







default:


}

}

}




switch task {







default:


}

}

}




switch task {







default:


}

}

}

Schedule app update background requestBackground Refresh

Schedule requestsOn complete of requests• Complete WKURLSessionRefreshBackgroundTask• Schedule snapshot• Reload complication

// Schedule the network request to keep the app snapshot up-to-date

func scheduleDataUpdateRequest() {

// Setup download tasks

self.setupAppDataRequest()

self.setupComplicationDataRequest()

// Setup finishUpdateHandler

self.finishUpdateHandler = { sessionIdentifier -> Void in

if let taskToComplete = self.urlSessionTasks[sessionIdentifier] {

self.scheduleSnapshot()

self.reloadComplication()

taskToComplete.setTaskCompleted()

}

}

self.submitRequests()

}












}

}


}












}

}


}












}

}


}












}

}


}












}

}


}

// NSURLSessionDelegate Background Download Tasks Complete

@objc func urlSessionDidFinishEvents(forBackgroundURLSession session: NSURLSession) {

if let identifier = session.configuration.identifier,

finishUpdateHandler = self.finishUpdateHandler {

finishUpdateHandler(identifier)

}

}






}

}






}

}

Background refresh recapStocks

Optimize how often you schedule updates for your appIf updating with data from a server, try to use single specialized endpoint

Resume Time Optimizations

Resume timeStocks

Minimize work during willActivate and didAppear• Avoid long running tasks that are triggered from willActivate• Smart load/reload of data• Only set properties on WKInterfaceObjects that have changed

Cautionary tale for Vertical Detail Paging APIResume Time

Neighboring detail pages will have willActivate calledAvoid expensive operations in willActivate for detail pages


Neighboring detail pages will have willActivate calledAvoid expensive operations in willActivate for detail pages


Reports of slow loading chart when entering first detail pageOther detail pages never finished loading their charts

// Initial Approach - willActivate/didAppear in StockInterfaceController.swift

override func willActivate() {

super.willActivate()

downloadAndGenerateChart()

}

override func didAppear() {

super.didAppear()

}

func downloadAndGenerateChart() {

// Long running task to download chart data and generate chart image

}





}


super.didAppear()

}



}





}


super.didAppear()

}



}

// Better Approach - willActivate/didAppear in StockInterfaceController.swift



}


super.didAppear()


}

override func willDisappear() {

super.willDisappear()

cancelDownloadAndGenerateChart()

}



}

func cancelDownloadAndGenerateChart() {

//Cancel long running task to download chart data and generate chart image

}




}


super.didAppear()


}




}



}



}




}


super.didAppear()


}




}



}



}




}


super.didAppear()


}




}



}



}

Vertical Detail Paging API caveatsResume Time


Avoid triggering long running tasks in willActivate


Avoid triggering long running tasks in willActivateMake use of cancelable operations

WKInterfaceTable loadingResume Time


All rows are loaded in memory


All rows are loaded in memoryThere is a linear upfront cost to the number of rows you have in your table


All rows are loaded in memoryThere is a linear upfront cost to the number of rows you have in your tableNo reuse


Initial Launch Time of Stocks

Tim

e

5.5s

6s

6.5s

7s

Number of Stocks in List0 1 5 10

Improve WKInterfaceTable loading performanceResume Time


Limit the number of rows you load


Limit the number of rows you loadDo smart updates of your table when row deltas occur

// Initial Approach - Load Stocks Table

func loadTable() {


self.table.setNumberOfRows(stocks.count, withRowType: stockRowControllerIdentifier)

for (index, stock) in stocks.enumerated() {

self.populateStockRowController(index: index, stock: stock)

}

}


func loadTable() {





}

}


func loadTable() {





}

}



Number of stocks in list is not capped


Number of stocks in list is not cappedAlways usingsetNumberOfRows(numberOfRows: Int, withRowType rowType: String)

// Second Approach - Load Stocks Table

func loadTableSmart() {


let stocksCount = min(stocks.count, maxStocksListSize)

let stockRowDelta = stocksCount - self.table.numberOfRows

self.insertRemoveTableRows(stockRowDelta: stockRowDelta)

for ( index, stock ) in stocks.enumerated() {

guard index < maxStocksListSize else {

break

}


}

}









break

}


}

}









break

}


}

}









break

}


}

}









break

}


}

}









break

}


}

}

// Second Approach - Load Stocks Table - insert/remove table rows

func insertRemoveTableRows(stockRowDelta: Int) {

let stockRowChangeRange = NSRange(location: 0, length: abs(stockRowDelta))

let stockRowChangeIndexSet = NSIndexSet(indexesIn: stockRowChangeRange)

if stockRowDelta > 0 {

self.table.insertRows(

at: stockRowChangeIndexSet,

withRowType: stockRowControllerIdentifier

)

}

else if stockRowDelta < 0 {

self.table.removeRows(at: stockRowChangeIndexSet)

}

}









)

}



}

}









)

}



}

}









)

}



}

}









)

}



}

}









)

}



}

}



Number of stocks in list is capped


Number of stocks in list is cappedInserting/removing rows is much more efficient than reloading the entire table



Instead of iterating over entire table when single rows are updated, consider:


Instead of iterating over entire table when single rows are updated, consider:• Use rowController(at index: Int) -> AnyObject? to get RowController

to be updated


Instead of iterating over entire table when single rows are updated, consider:• Use rowController(at index: Int) -> AnyObject? to get RowController

to be updated• Store a reference to the RowController to update later

Updating your UI elementsResume Time

WKInterfaceObjects are modified in the extension processUpdates to these properties are sent from extension process to app processApp process handles layout of interface

Already Set!!

Updating your UI elementsResume Time

WKInterfaceObjects are modified in the extension processUpdates to these properties are sent from extension process to app processApp process handles layout of interface

Already Set!!

WatchKitExtension

WatchKit UI

StocksInterfaceController layoutResume Time

@IBOutlet weak var platter: WKInterfaceGroup!

@IBOutlet weak var listNameLabel: WKInterfaceLabel!

@IBOutlet weak var changeInPointsLabel: WKInterfaceLabel!

@IBOutlet weak var priceLabel: WKInterfaceLabel!




































// Initial Approach - Update StockRowController

func update(listName: String, price: String, changeInPoints: String,

changeLabelColor: UIColor, platterColor: UIColor) {

self.platter.setBackgroundColor(platterColor)

self.listNameLabel.setText(listName)

self.changeInPointsLabel.setText(changeInPoints)

self.changeInPointsLabel.setTextColor(changeLabelColor)

self.priceLabel.setText(price)

}

Improve layout update performanceResume Time


Properties on WKInterfaceObject are not cached


Properties on WKInterfaceObject are not cachedSetting a property on WKInterfaceObject sends that value to the app process every time


Properties on WKInterfaceObject are not cachedSetting a property on WKInterfaceObject sends that value to the app process every timeOn average, 200ms for value to move from extension to app process


Properties on WKInterfaceObject are not cachedSetting a property on WKInterfaceObject sends that value to the app process every timeOn average, 200ms for value to move from extension to app process1.4s worst case scenario when initially loading the stocks list

// Better Approach - Update StockRowController Part 1

func update(listName: String, price: String, changeInPoints: String, changeLabelColor:

UIColor, platterColor: UIColor) {

if self.platterColor?.hash != platterColor.hash {

self.platterColor = platterColor


}

if self.listName?.hash != listName.hash {

self.listName = listName


}

// ...

}







}




}

// ...

}







}




}

// ...

}







}




}

// ...

}

Resume time recapStocks


Minimize work performed willActivate and didAppear


Minimize work performed willActivate and didAppearMake use of cancelable operations


Minimize work performed willActivate and didAppearMake use of cancelable operationsOverly complicated user interfaces will lead to slower resume times


Minimize work performed willActivate and didAppearMake use of cancelable operationsOverly complicated user interfaces will lead to slower resume timesOnly update your user interface when necessary

Summary

Summary

Think small• Keep tasks small and easy to perform• Simplify your user interface• Make use of new Background Refresh APIs

Summary

Think small• Keep tasks small and easy to perform• Simplify your user interface• Make use of new Background Refresh APIs

Focus on resume time• Pay attention to WKInterfaceController lifecycle methods (especially willActivate and didAppear)

• Make use of cancelable operations• Optimize when updating your user interface

More Information

https://developer.apple.com/wwdc16/227

Related Sessions

What’s New in watchOS 3 Presidio Tuesday 5:00PM

Quick Interaction Techniques for watchOS Presidio Wednesday 11:00AM

Designing Great Apple Watch Experiences Presidio Wednesday 1:40PM


Concurrent Programming With GCD in Swift 3 Pacific Heights Friday 4:00PM

Advanced NSOperations WWDC 2015

Labs

WatchKit and WatchConnectivity Lab Frameworks Lab B Friday 2:00PM

Documents

Architecting for Performance on watchOS 3€¦ · Redistribution or public display not permitted without written permission from Apple. App Frameworks #WWDC16 ... Agenda 2-Second