One thing is for sure. Apple is working on something big. We’re not even exactly sure how big just yet.
This year, it seems many tech companies are focusing on “quality of life” (QOL). Usually the phrase “quality of life update” refers to a software update that makes many changes to an application or game to improve the overall experience – usually a combination of bug fixes, interface tweaks, performance enhancements, and anything else that improves someone’s experience with a particular piece of software. However, most recently, we’ve noticed more and more emphasis being placed on the user’s QOL rather than the software. Both Apple and Google have released features to help users spend less time on their phone and more time with those around them. Digital Health is not a new concept, but it does seem to have gone by the wayside in recent years. Although not the one key takeaway that we chose to highlight in this article (but it was a close second), we would be remiss if we didn’t mention the hot topic of app optimization. Quite a bit of time was spent covering how developers could and should optimize apps in every way possible – in file size, performance, and amount of time users need to spend in it to accomplish the desired task (which you should be doing anyway).
Speaking of QOL, Apple spent a majority of the keynote announcing new features for their apps and devices. Things like Search Suggestions for photos, updates and UI changes for several first-party apps, new workouts on the Apple Watch, and much more. They also announced that you could FaceTime with 32 people while using your own emoji, aptly named Memojies (below).
A majority of these updates benefited the ultimate end users of Apple devices while some helped developers more easily and effectively build on Apple’s platforms. There was, however, one update that stood out above the rest as the “killer feature” for apps this year. And that feature, is Siri Shortcuts.
These. Are. Big. Siri Shortcuts will change how a lot of people interact with a lot of apps. Since the emergence of DVAs (Digital Voice Assistants), the biggest barrier for adoption has been the learning curve for users. “What can I ask it? Was it how I phrased it? I didn’t want it to open that app to do ____.” are all statements you may have muttered to yourself when trying to communicate with your Google Home, Home Pod, or Amazon Echo. But Siri Shortcuts are going to change that. Instead of adding voice-controlled features to an app that users may or may not ever discover, developers can now prompt users with a button to “Add to Siri.” This does not add a particular action to Siri, but instead it allows users to create their own custom phrase to activate a certain feature that the app allows. For example, instead of having to say “Hey Siri, play my ‘Running’ playlist in Spotify,” someone can create a custom phrase for “Hey Siri, I’m going on a run” and the outcome will be the same.
This doesn’t sound like much, but this could change Siri’s role to many as a peripheral accessory of the iPhone to an app necessity. Instead of having to try several times to get a request to work, users can simply make their own. As we aren’t exactly sure on how this will work just yet, we are assuming it will be based on deep linking.
Another reason apps need to be Siri-ready is that Shortcuts will not just be for individual actions, but for a series of actions. Seen above, when asked “how’s the surf,” Siri began running through the requests the user had previously set up – like checking the weather and getting directions to the beach. Other examples Apple provided were Siri Shortcuts for “time to go home” or “let’s go to work.” In the “let’s go to work” example, Siri automatically knew to order a coffee from Starbucks that the user gets on the way to the office every day. So, for example, if your brand allows pick-up for groceries, you may want to integrate Siri in a way that allows people to create a grocery list of common items they need each week so users can order with a simple phrase.
By creating useful Siri integrations that can become part of a larger, daily/weekly/monthly routine instead of a one-off request, branded apps can quickly become a necessity of life even if they aren’t being manually launched. Like in the example above, the user with the morning routine didn’t open the Starbucks app, but they still bought a coffee.
Stay tuned for more from Apple’s developer conference or contact us today to learn more about Siri Shortcuts and how your brand can best leverage them.
In iOS 11, Apple has made a number of improvements to the URLSession family of APIs. These improvements range from developer quality of life updates, to significant performance gains that will undoubtedly improve user experiences across the platform. In this post, we’ll go over two improvements in particular: Multipath TCP support and reachability monitoring built-in to URLSession.
Elegantly handling poor network conditions is a sure sign of a well-built and polished app. Compared to most other apps on your phone, have you ever noticed how rarely Siri seems to have connectivity issues? The reason for this is Multipath TCP. When Siri makes a network request, the app actually opens up two connections to the server: one over Wi-Fi and one over cellular. These connections work together to deliver data to the app as quickly as possible. As long as your device has a decent connection on one of the two channels, Siri works.
Multipath TCP is a relatively new protocol, designed specifically for mobile devices. It is built on top of TCP, so it benefits from the reliability and congestion controls built into TCP. Additionally, MPTCP allows for seamlessly switching between a wireless and cellular connection. It even supports using both connections simultaneously to increase throughput (more on this later).
In order to take advantage of MPTCP, support is required at both the Client and Server level. Not all server infrastructures currently support MPTCP, but popular vendors like AWS do. With iOS 11, app developers can now support MPTCP at the client level as well.
In iOS 11, apps can opt into three different MPTCP modes: Handover Mode, Interactive Mode, and Aggregate Mode
Regardless of which mode is used, the cellular link will be disabled if your app hits the Wi-Fi assist data limit. Be on the lookout for this if you are testing your apps and notice MPTCP no longer switching over to cellular. This is a good indicator that you may need to rethink which calls are opted in to MPTCP.
So, how do you opt in? Apple has made this extremely easy. Simply add the “multipath” capability to your app in Xcode, and set the multipathServiceType property on your URLSessionConfiguration to either .handover or .interactive. That’s it!
Good reachability handling has always been tricky in iOS, mostly due to the absence of solid high-level support for it. Most apps use third- partyreachability libraries, all of which are built on top of Apple’s SCNetworkReachability low-level API. There are some issues with this approach: the libraries are not particularly reliable, and they are not integrated with URLSession. If a developer needs to hold off on making a network request until network conditions improve, or retry a network request, they have to build that functionality up from scratch themselves. That ends up being cumbersome for developers, results in less than ideal reachability handling, and also takes time away from polishing the user experience. Developers often take the easy route and present a full-screen modal as soon as connectivity is lost, blocking the user out of the app completely.
Apple has improved a number of these pain points in iOS 11. URLSession now has the ability to monitor network conditions and wait to start tasks. You can easily opt in to this behavior by setting waitsForConnectivity to true on your session’s configuration. When opted in to waitsForConnectivity, URLSession will either load the request immediately or load the request as soon as network conditions allow. While waitsForConnectivity is defaulted to false for backwards compatibility, Apple recommends enabling it for almost all requests.
In addition to delaying network requests, URLSession will now notify your app when it experiences poor connectivity. This is accomplished via the urlSession(_:taskIsWaitingForConnectivity:) delegate callback. You can hook into this delegate callback and use it to toggle Connectivity UI.
Do you have burning questions about connectivity with iOS 11? Our developers, responsible for numerous award-winning apps and connected device experiences, have the answers. Tell us what you’re wondering at [email protected]
As most iOS developers are aware, breakpoints are an essential tool to debugging apps. In Xcode, setting a breakpoint is as easy as clicking on the line number that you want to pause app execution on. When execution is paused, you can view the state of any variables in scope, issue commands to the debugger, and even step through your code line-by-line to watch the execution flow unfold before your eyes.
To make your debugging experience with breakpoints even better, we’ll cover the 5 breakpoints that every iOS developer should enable. If you’re a seasoned iOS developer, you may already know about some of these. If you’re new to iOS development, don’t worry, we’ll start with a quick overview of how to setup and use breakpoints.
Managing breakpoints in Xcode is super simple. Enter the Breakpoint Navigator, which lives in the Navigator Panel on the left side of Xcode. Here, you will see all the breakpoints currently set in your project. Click on the name of the method to jump right to that line of code or click on the blue breakpoint icon to enable/disable the breakpoint. Removing a breakpoint is as easy as dragging it outside of the panel.
While it’s very useful to set breakpoints on specific lines of code, it can also be helpful to have some breakpoints function globally. Symbolic breakpoints are breakpoints that will trigger on certain conditions, like any time a certain method is called on a class. Adding a symbolic breakpoint is achieved by clicking the "+" icon at the lower left of the Breakpoint Navigator and selecting “Symbolic Breakpoint”.
Here we are, the secret sauce! Use the "+" button at the bottom left of the Breakpoint Navigator to add the following breakpoints:
This breakpoint catches exceptions thrown by Objective-C code. Due to the current transition to Swift, this breakpoint isn’t as useful as it once was, but it can still be handy if your app contains any Objective-C code or uses third-party libraries that are written in Objective-C.
Turn it on:
This puts a breakpoint at the entry point to your application’s launch. We’ll be using the "Debugger Command" action again to have our debugger import UIKit, which will make the debugger much more aware of properties and methods on things like UIView. This will make it easier to interact with and print properties on these types of classes when you’re debugging.
Turn it on:
This breakpoint helps you catch undesirable constraint configurations. If you’ve ever seen the “unable to simultaneously satisfy constraints” error message in the console, it will suggest you set a breakpoint here. Usually, these situations don’t cause obvious visual errors, but they should be fixed since we don’t know how they will be handled in future versions of iOS.
Turn it on:
NOTE: In Xcode 9, there is a new "Constraint Error" breakpoint that can be used instead of manually creating this symbolic breakpoint.
This is another breakpoint to help you identify Auto Layout constraint problems. Hitting this breakpoint is typically much less common than hitting the "UIViewAlertForUnsatisfiableConstraints" breakpoint above, but it’s still good to go ahead and make sure you turn this one on.
Turn it on:
This last breakpoint helps catch layout errors in UICollectionView’s flow layout. This is especially useful if you ever work with self-sizing collection view cells or create your own flow layout subclass.
Turn it on:
As you can imagine, it can be quite tedious and time consuming to create all five of these breakpoints for every project you work on. This is where the power of promoting your project breakpoints to "User Breakpoints" comes into play. User Breakpoints will automatically be present in any Xcode project you open! To convert a breakpoint to a user breakpoint, right-click on the breakpoint and choose "Move Breakpoint To" -> "User."
When everything is said and done, you should now have five breakpoints listed under "User" in the Breakpoint Navigator. These breakpoints will be set up for any Xcode project you open from here on out. Also, notice that any project-specific breakpoints will be listed above these "User" breakpoints, under your project’s name.
Now that WWDC 2017 has concluded, it's time to evaluate any apps you currently have in the App Store, as well as any soon to be released, to ensure that they're ready for the new version of iOS. It's not a very long list, but the changes are important.
Once you've completed these must-do tasks, there are a few other things that can help make your app more modern and relevant. Generally speaking, these are more technical, so you don't necessarily need to keep going from this point.
The first of these optional items would be replacing any icons in your app with vector art. You've been able to use PDF vector art to provide images for quite some time, and there are additional areas where these will be used (such as accessibility hints for toolbars). This should be a straightforward change for ongoing development.
The second optional item would be to simplify any of your custom JSON transformations using the new Swift Codable protocol. This functionality should be backward compatible back to iOS 6, and this can give you a simpler, lighter-weight application.
If you support a user login system on the web as well as your app, you should definitely prepare to share those logins using the new password support. There are very few steps needed to complete these logins, and it can allow the user to use more secure passwords.
You should consider updating any animations in your app that are frame-locked to 60Hz. Having animations locked to a particular refresh rate can cause less-than-ideal appearance on the most recent iPad pro, which has a 120Hz refresh rate. Future devices may have refresh rates other than 60Hz as well, so preparing for that future would be a wise move.
Hopefully you're inspired to get your app ready for the next version of iOS. If you get started now, this is a very light lift for most apps that have been well maintained. Your users are certain to be appreciative of your app if it's kept current with the latest developments.
Want to make sure your app is ready for iOS 11? Reach out and let’s talk about it.
Bottle Rocket is a digital transformation company that leverages a unique Connected Customer mindset to build technology-enabled solutions that propel businesses and delight customers.
© 2020 Bottle Rocket. All Rights Reserved.