One thing is for sure. Apple is working on something big. We’re not even exactly sure how big just yet.
Bottle Rocket is best known for designing and developing mission-critical mobile experiences for some of the world’s most discriminating brands. But for one very special cause, we went back to our roots in mobile gaming to launch a game that is something very special. Now available from Bottle Rocket and the Make-A-Wish Foundation: Planet SRAM, a single-player shooter that pits players against waves of out-of-this-world creatures like giant tree monsters that shoot snakes from their heads.
Those tree monsters and snakes? We didn’t come up with those. Planet SRAM comes from the mind of 11-year-old Hunter Allis, who met Bottle Rocket through Make-A-Wish. Reflecting on Planet SRAM’s development, Bottle Rocket Founder and CEO Calvin Carter said, “This journey allowed us to do even more of what we love and share our craft with someone that loves it just as much as we do. We are honored and humbled to have had this opportunity to serve a wonderful and deserving family, as well as a truly impactful organization.”
Download Planet SRAM now on iOS for an exciting and action-packed look into the super creative mind of a boy with passion and a whole lot of heart.
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.
© 2020 Bottle Rocket. All Rights Reserved.