fbpx

August 22, 2019

WWDC 2019 Keynote Recap: This is Only the Beginning

One thing is for sure. Apple is working on something big. We’re not even exactly sure how big just yet.

Read more

September 25, 2017

Blast Off to Planet SRAM

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.

August 24, 2017

Engineering Jedi: Maximize Connectivity in iOS 11

We’ve made you aware of things you should prepare for with iOS 11, now we’re looking at something more specific: how poor network connectivity will be handled with the upcoming iOS update. The lay user just needs to know you may use slightly more mobile data than you have before once you update to iOS 11. But for our fellow developers, we’re going deep into this subject below. Put on your engineer hats!

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.

Multipath TCP

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.

Modes

In iOS 11, apps can opt into three different MPTCP modes: Handover Mode, Interactive Mode, and Aggregate Mode

  • Handover Mode: Connection will be made over Wi-Fi when possible. If Wi-Fi network conditions are poor, the system will automatically spin up a cellular link and transfer the traffic to it. As Wi-Fi conditions improve, traffic will be transferred back to a Wi-Fi connection and the cellular link will be torn down. Essentially, handover mode attempts to minimize cellular usage while still maintaining acceptable performance. All of this happens in URLSession and is completely transparent to our apps.
Diagram of cell tower and wifi for Handover mode
  • Interactive Mode: The system will immediately spin up both a Wi-Fi and Cellular link. While Wi-Fi is still preferred, the system will be aggressive about transferring to cellular if it finds that Wi-Fi conditions are not ideal. Interactive mode is optimized for performance, at the cost of cellular data usage. Siri uses Interactive mode.
  • Aggregate Mode: Like Interactive mode, the system will immediately spin up two links. However, both links will be used together to increase the overall throughput of the network. In theory, using Aggregate mode over a 10mbps Wi-Fi connection and a 5mbps cellular network could result in a 15mbps connection to your server! While this is very cool, it can cause significant cellular data usage. Because of this, Apple is not allowing Aggregate Mode to run in Production apps. Aggregate mode is, however, available to developers via the Developer Settings screen in the Settings app.

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.

Opting In

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!

xcode example of activating handover mode

Reachability

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]

July 10, 2017

Engineering Jedi: iOS Breakpoint Secret Sauce for Better Debugging

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.

gif of setting up a point break in xcode

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.

The Breakpoint Navigator

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.

screenshot of breakpoint navigator UI

Symbolic Breakpoints

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”.

selecting symbolic breakpoint in breakpoint navigator

The Top 5 Xcode Breakpoints

Here we are, the secret sauce! Use the "+" button at the bottom left of the Breakpoint Navigator to add the following breakpoints:

All Objective-C Exceptions

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:

  1. Add an "Exception Breakpoint"
  2. Change the "Exception" value from "All" to "Objective-C"
  3. Click "Add Action" to add a "Debugger Command" action
  4. Type in "po $arg1" for the command. This will automatically print the relevant error to the console when you encounter an exception
adding in all breakpoint exceptions

-[UIApplication main]

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:

  1. Add a "Symbolic Breakpoint"
  2. Type in "-[UIApplication main]" for the Symbol
  3. Add a "Debugger Command" action
  4. Enter "expr @import UIKit" for the command
  5. Check "Automatically continue after evaluating actions" — this will ensure that your app doesn’t immediately pause execution every time you build and run
adding breakpoint in debugger command

UIViewAlertForUnsatisfiableConstraints

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.

setting up UIViewAlertForUnsatisfiableConstraints

Turn it on:

  1. Add a "Symbolic Breakpoint"
  2. Type in "UIViewAlertForUnsatisfiableConstraints" for the Symbol

NOTE: In Xcode 9, there is a new "Constraint Error" breakpoint that can be used instead of manually creating this symbolic breakpoint.

using constraint error breakpoint instead of using UIViewAlertForUnsatisfiableConstraints

-[UIView(UIConstraintBasedLayout) _viewHierarchyUnpreparedForConstraint:]

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:

  1. Add a "Symbolic Breakpoint"
  2. Enter "-[UIView(UIConstraintBasedLayout) _viewHierarchyUnpreparedForConstraint:]" for the Symbol
breakpoint to identify Auto Layout constraint issues

UICollectionViewFlowLayoutBreakForInvalidSizes

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:

  1. Add a "Symbolic Breakpoint"
  2. Enter "UICollectionViewFlowLayoutBreakForInvalidSizes" for the Symbol
catching errors in UICollectionView's flow layout

One More Thing - User Breakpoints

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.

checking the 5 breakpoints in breakpoint navigator

June 20, 2017

Engineering Jedi: Five(ish) Things to Prepare for with iOS 11

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.

  1. Prepare for the new App Store look and feel. Your app will get a new presentation style, and you're encouraged more than ever to use video to demonstrate the app. Also, reviews no longer reset with each submission to the App Store, so it's a good idea to decide on what interval you wish to reset those ratings averages. Related to the new store: you may need to remove any existing mechanisms prompting the user to rate the app. Starting now, only the built-in functionality is allowed for prompting the user. You can still use any techniques you prefer to decide when the stock technology should present the request, but be aware that the user will only receive that prompt at most three times per year, and may never see it due to choices that they've made.
  2. Apple has provided a new set of tools for determining where items should be placed on screen. Hopefully your app is already using AutoLayout, and is prepared for multiple device layouts using size classes. These have been around for a while, and should be considered the bare minimum for supporting modern devices. In addition, there's now a concept of the "safe area" on an iOS device. This is the area of the screen where critical user interactions should take place. This concept is common for development for televisions to account for overscan, but is new for iOS development. This may indicate that in future devices, interactive elements might not work if they're too close to the edge of the screen. Prepare now, and you can ensure that future devices won't hamper your users' experiences.
  3. In iOS 11, users can allow location services either in-app only or at any time. Some apps are designed to work only if they have access to the user's location at all times. These apps need to reconsider their location usage strategy and adapt to this new requirement.
  4. If your app uses a custom typeface, it is now much simpler to support dynamic type with those custom typefaces. This is often the first step in making your app accessible, and now you can easily set up your app to handle this combination of dynamic type and accessibility. If you had done this using some arbitrary custom code before, you can now handle it more completely and safely.
  5. Finally, if your app runs on the iPad, the time has never been more appropriate to adopt multitasking. With the new multitasking features and drag-and-drop support, it's more important than ever to support these techniques, so that your app remains relevant to advanced users of these devices.

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 Logo
digital transformation redefined.

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.

© 2019 Bottle Rocket. All Rights Reserved.