Creating Great Enterprise Apps for iOS

On Enterprise Apps

What’s wrong?

“There’s an App for that” is perhaps one of the most well-known advertising slogans of the last ten years. Indeed, since the birth of the iPhone, owners of mobile devices have come to enjoy high-quality, often freely available, applications for achieving virtually any task they can imagine.

For publicly available apps, user experience is often make or break; the App Store makes it relatively easy to find an alternative for any common app. In contrast however, Enterprise apps are generally mandated by a company’s IT department or some other internal function. Since these enterprise apps aren’t therefore subject to normal market-forces, I’ve found that they can often be of significantly lower quality, both in terms of user experience and feature sets.

Here’s a great clip from Steve Jobs talking about exactly this issue:

Steve Jobs at D8 Conference, 2010

There is seemingly little incentive for companies to improve apps which are compulsory for their employees. Or is there? More companies are starting recognise the link between internal employee user experience and employee retention. Retaining the best employees can be key to a company’s success, particularly within the technology industry.

This is likely to become an even more important battleground in the post-COVID world, as companies from around the world compete to hire the very best people. When people are working remotely- the majority of their interaction with the company they work for and its processes are via the various apps and other software it provides.

How can we fix it?

Consider the alternatives

There are a huge number of off-the-shelf enterprise apps available. Don’t try and build your own internal app for emailing or messaging: just provide your employees with a great existing app such as Outlook or Slack. You’ll find this far cheaper (and much less stressful!) than embarking on a whole development journey.

For existing internal content, such as news items or other text-based information, which are delivered through the web when using desktop: consider optimising these sites for mobile rather than developing a mobile specific app. Let the users view this in Safari, so they have the ability to enter Reader Mode, and don’t force them to access the content through a “fake”, web-view based mobile app. There’s no shame in delivering great content through the web, there is in providing users with a poor experience through a badly made web-based app.

Don’t overcomplicate things

Still here? You must be sure a mobile app is the right thing for your use-case.

Disclaimer: because of where my knowledge and experience lies, I’m going to assume we’re focussing on a native iOS app from this point on. Some, but not all, of the point below will apply to native Android apps, cross-platform apps and hybrid apps. There are also plenty of other articles that will discuss the pros and cons of such things.

Ok: let’s start with a simple app then. This one is potentially more for app designers than developers but, as with most iOS development, I’d suggest using native components and standard UI flows wherever possible. The majority of apps in this environment can be created using tab-bars, navigation controllers, table views and the odd collection view: think Apple Music, Notes or even third-party apps like the new GitHub app.

This will allow you to build your app much quicker without worrying how to make your custom components. If you try and build the whole app with custom components, you can quite quickly end up with a problem of quantity over quality and end up with a poorer overall experience.

Enterprise Apps on iOS


When creating a bespoke enterprise apps, that is to say one which is made for a specific organisation, you are often able to gather much better information about your users and how they will interact with your app.

Firstly, when companies provide devices to their users, developers can often make assumptions and tailor apps to these specific devices. For example, in some projects I’ve worked on we’ve only had to consider one specific iPhone or iPad screen-size, which can massively simplify both development and testing.*

* Note I’d still recommend following best practice and using autolayout and size classes to support other devices. This way you’ll find it easier to add new devices in the future as well as potentially making your app more accessible by supporting dynamic type.

Secondly, managing devices means we can add constraints, such as ensuring all our users are running the latest version of iOS. This is very exciting for developers as it means we can always use the latest APIs and features in iOS, that usually we have to wait for! As a reminder: in iOS 14 this means App Clips, Widgets and more!


In late 2019, Apple added support for Custom Apps deployment to iOS. This Custom Apps approach is effectively an overhaul of the not-quite-yet deprecated Developer Enterprise Program (DEP). Since then Apple has dramatically restricted entry to the DEP, likely as a response to one particular, high-profile, breach of contract.

For those still using the DEP, Custom Apps offers a few key advantages, over the former approach:

Apps are uploaded to App Store Connect, as for public App Store apps
Downloads can therefore benefit from all the great App Store features: both internal and external users can access pre-release versions of the app using TestFlight, and downloads can be much faster thanks to Apple provided worldwide CDN hosting as well as app thinning.

On the flip-side, since they’re now distributed through Apple, they must go through App Review in the same way as publicly App Store apps. If you’re used to developing for the App Store anyway, you’ll be used to this. Those moving from DEP to Custom Apps may find App Review adds an extra few days to their deployment process.

Apps are re-signed by Apple
As apps are deployed to devices, they are re-signed with Apple’s master certificate. Apps signed with this certificate will not expire every year as they do with Enterprise-signed installations. Furthermore, users no longer have to install additional certificates or provisioning profiles on their device, a key gain for device security as we’re not teaching users bad habits!

Apps can be distributed to clients
Whereas the Enterprise Program allows businesses to distribute apps to their own employees only, Custom Apps allows apps to be distributed to users at other organisations. This is great news for third-party Enterprise app developers, as apps no longer need to be re-signed by their clients before distribution.

N.B. Custom Apps requires Apple Business Manager, or its education sibling: Apple School Manager. As of Dec 2020, these are still only available in 69 countries, so if you are deploying outside of these regions you will need to apply to be part of the DEP.

Mobile Device Management

Most large organisations want to have some level of control over the data that their employees store on their computers, and mobile is no exception to this. Mobile Device Management solutions are the solution for this.

There are many off-the-shelf products for Mobile Device Management, but from a developer’s point of view, they all perform the same main functions:

  • automatically configuring the device for access to employer provided tools, such as email or VPN access
  • restricting certain features of the device depending on purpose:
    • i.e. iOS devices can be used in Kiosk mode for a specific application
    • full web-access can be blocked, or only certain WiFi networks may be allowed

Managed App Configuration

All of the main Mobile Device Management solutions support Apple’s Managed App Configuration.

The online documentation for Managed App Configuration is pretty poor, but the concept is simple. The organisation can provide an XML-based .plist file containing various values that can be read by the app.

Managed App Configuration is not exclusive to Enterprise-only apps. You can add support for configuration to your App Store apps too, which will allow organisations to customise / pre-configure the app for their employees! For example: Microsoft Outlook for iOS can be pre-populated with a user’s email credentials so employees don’t need to set this up manually.


As remote working becomes more the norm than the exception, the amount we interact with our enterprise apps is ever increasing. The steps I’ve laid out should be a great starting point on your journey to provide your employees or users the best possible user experience when interacting with your enterprise apps.

Get in touch?

Going iOS native with WordPress

WordPress is one of the most popular website platforms available, in fact it powers just under a third of the entire web, including this very website. WordPress is a great tool for all kinds of websites, and the web in general is great for distributing content to a massive number of users, but it cannot match the user experience that can be provided through native apps.

As most of my work focusses on iOS, I decided to use the WordPress API to see if I could make my blog (this website) available as a native app. I released this recently – you may even be using it to read this post – though I’ll let you be the judge of how well it’s been executed.



Supporting Web allows the site to be accessed by the widest possible number of users. The website is available to users on Desktop PCs, smartphones from all manufacturers*, tablets and even TVs.

*Disclaimer: I haven’t checked them all.


Native apps feel more intuitive to users as they tend to follow the UI standards of the individual operating system more closely. While this app is relatively simple, making it native would allow it to make the most of the vast array of APIs and hardware available on iOS devices.

For starters, this app makes the most of the accessibility features in iOS by providing support for Dynamic Type and VoiceOver, as well as giving users the ability to read posts while they are offline. You can see from these images that the iOS app obeys the user’s dynamic type choice while the web app displays text at the default size.

Blog post viewed on the web in Safari
Blog post viewed in the native iOS app

While it is possible to support dynamic type on the web, we don’t get as much control over it, nor as much given for free as we do using the iOS SDK.

Going native also would allow us to make the most of additional iOS features such as widgets, augmented reality, Pencil, iMessage apps, and so much more.



Since I use WordPress for writing my blog, there is no need for any extra work to create a backend API for the app. WordPress provides a REST API which I can use to easily query the site to retrieve the list and content of my posts to display to the user. Easy, right?

        "id": 132,
        "date": "2020-09-05T16:00:41",
        "modified": "2020-10-15T07:50:39",
        "slug": "going-for-gold-taking-full-advantage-of-apple-platforms",
        "link": "",
        "title": {
            "rendered": "Going for Gold- Taking full advantage of Apple Platforms"
        "content": {
            "rendered": "
                <p class=\"has-drop-cap\">
                    In a recently published <a href=\"\">
                    blog-post on building widgets for iOS 14

We can represent this as a UML diagram, to give visual representation of the different objects we can create in Swift and how they are related.

UML Class Diagram for WordPress post API

If you’ve read some of my previous posts, you’ll be familiar with Swift’s Decodable protocol for decoding values from JSON representation.

Although we can convert this directly into a Swift struct representation

For Swift beginners: a struct is similar to a class, but more lightweight and recommended as the default building block for Swift objects. For a full comparison of the two, I’d recommend reading this chapter from the Swift Language Guide.

struct Post: Decodable {
    let id: String
    let slug: String
    let title: String
    let link: URL
    let jetpack_featured_media_url: URL?
    let date_gmt: Date

It would be much better to use CodingKeys to transform these variables to more closely follow the Swift Naming Guidelines, including the use of camel-case rather than snake-case:

struct Post: Decodable {
    let id: String
    let slug: String
    let title: String
    let link: URL
    let imageURL: URL?
    let publishedDate: Date

    enum CodingKeys: String, CodingKeys {
        case id, slug, title, link,
        case publishedDate = "date_gmt"
        case imageURL = "jetpack_featured_media_url"

Not so fast…

While this means we can easily get the lists of posts using a simple API query in our iOS app, we still need to convert that rendered content into native iOS components. I defined a set of components that I use to write the blog and created an enum in Swift:

enum PostContent {
    case heading1(String)
    case heading2(String)
    case body(NSAttributedString)
    case image(URL)

    case horizontalRule

I used SwiftSoup to parse the HTML string provided by WordPress:

let xml = try? SwiftSoup.parse(contentHTML)

We can create an initialiser for converting SwiftSoup‘s Element type into our enum:

extension PostContent {
    init(element: Element) throws {
        switch element.tagName() {
        case "h1":
            self = try .heading1(element.text())
        case "hr":
            self = .horizontalRule
        // etc.
        // ...

then map our rendered content into the PostContent type we just created:

let content = xml?.body()?.children().compactMap {
    try? PostContent(element: $0)


Now that we’ve converted the raw HTML string into a data model, we can think about transforming this into views that we can display on the screen. I’ve used SwiftUI for this, but we could add specific implementations for UIKit or AppKit, or even something a bit more off-piste such as exporting to PDF or another type of document.

SwiftUI’s ViewBuilder allows us to easily map our internal PostContent type into its SwiftUI representation, using a set of very readable code.

func viewForContent(_ content: PostContent) -> some View {
    switch content {
    case .heading1(let string):
    case .heading2(let string):
    case .horizontalRule:
    // etc.
    // ...

Using SwiftUI, we get support for many of the great native features I described above, including dynamic type, dark mode and more, out-of-the-box. This works great for the majority of the components. As you can see from the code-snippet above, some elements, such as the horizontal rule, can be mapped directly. However some may require a little bit more work.



Supporting rich-text with bold text, links and more isn’t easy in SwiftUI as it has no out-of-the-box support for rendering HTML or NSAttributedString. I found the easiest way to implement is to bridge into UIKit with a UIViewRepresentable class to display a UILabel which will display the HTML content provided by the API using NSAttributedString. If all this sounds like Greek to you, don’t worry: I will explain it step-by-step!


Our response from the server will return content which should be displayed like this:

“This is a paragraph containing some bold, underlined text.”

However, since the server returns raw HTML text, if we decode this directly into a Swift string, we will display:

“This is a paragraph containing some <b>bold, <u>underlined</u></b> text.”

Luckily the iOS SDK provides an easy way to turn this into an NSAttributedString which can be displayed on the screen with the bold and underlined characters we would expect.

let excerpt = try? NSMutableAttributedString(
    data: Data(excerpt.utf8),
    options: [.documentType: NSAttributedString.DocumentType.html],
    documentAttributes: nil)

You can find more details in this article from Paul Hudson.


Unfortunately SwiftUI doesn’t support rendering of NSAttributedString out-of-the-box, but with a bit of work, we can create a new AttributedText struct which will!

To do this, I’ve chosen to use UITextView, rather than UILabel, as it has inbuilt support for HTML links- but don’t forget to disable editing!

struct SwiftUILabel: UIViewRepresentable {
    // We can pass in the text we initialised above!
    @State var attributedString: NSAttributedString?

    func makeUIView(context: UIViewRepresentableContext<Self> -> UITextView {

    func updateUIView(_ uiView: UITextView, 
                      context: UIViewRepresentableContext<Self>) {
        uiView.isEditable = false
        guard let attributedString = attributedString else {
        uiView.attributedText = attributedString

Great, now let’s run it.

HTML mark-up rendered as a UILabel within SwiftUI.

It works! Our text appears bold, italic, underlined and even in a monospaced font as we would expect. We even get support for numbered and un-numbered bulletpoints.

There’s just a small problem, and it’s hard to spot, but SwiftUI doesn’t seem to obey the intrinsic content size of the UILabel, so we get some large gaps in between our content. Here’s the comparison:

SwiftUI adds too much padding above and below the text.
This causes some layout issues in the scroll view.

I’ve found that the best way to do this is to place the SwiftUILabel inside a wrapper which can manually set the frame to the height. We can use a binding to pass the expected height through to the inner type: this allows both to stay up-to-date with the latest value, with any changes being rendered on the screen.

import SwiftUI
import UIKit

struct AttributedText: View {
    // We can pass in the text we initialised above!
    @State var attributedText: NSAttributedString?
    @State private var desiredHeight: CGFloat = 0
    var body: some View {
        HTMLText(attributedString: $attributedText,
                 desiredHeight: $desiredHeight)
        .frame(height: desiredHeight)

struct SwiftUILabel: UIViewRepresentable {
    // We can pass in the text we initialised above!
    // N.B. This has been changed to a binding now!
    @Binding var attributedString: NSAttributedString?

    // A binding references the state of the parent class
    // Any updates we make here, trigger an update on the screen
    @Binding var desiredHeight: CGFloat

    func makeUIView(context: UIViewRepresentableContext<Self> -> UITextView {

    func updateUIView(_ uiView: UITextView, 
                      context: UIViewRepresentableContext<Self>) {
        guard let attributedString = attributedString else {
        uiView.attributedText = attributedString

        DispatchQueue.main.async {
            let size = uiView.intrinsicContentSize
            guard size.height != self.desiredHeight else { 
            self.desiredHeight = size.height

If you know a better way of doing this in SwiftUI, please do let me know!

In the final code, I’ve also added support for links within text which is fairly easy to do thanks to UITextView.

It works!

We’ve used the WordPress API to natively render a website on iOS with support for Dynamic Type and Dark Mode.

The entire source code for this app is available on GitHub:

Look out for a future article where I’ll describe how I made this app available without users needing to download it using App Clips for iOS 14.

Going for Gold- Taking full advantage of Apple Platforms

In a recently published blog-post on building widgets for iOS 14, I showed how to implement a home-screen widget to display the latest status of the London Underground network. In the sample project, I showed how a shared module could be used to share everything from networking code to SwiftUI views between both the actual app and the widget.

Since SwiftUI is supported on all of Apple’s platforms, and we can now create apps entirely with SwiftUI, I thought it would be interesting to see how easily we can adapt a similar app to support all Apple platforms, be accessible for all users, and implement as many flagship features as possible. SwiftUI makes it super easy to do this, but as developers we still need have each of these features at the back of our minds when we are working.

Sample code for this post is available on GitHub.
Make sure to checkout the going-for-gold branch of the repository!


WidgetKit / iOS

Let’s start assuming that we have implemented this, if you want more details on this, check out my previous blog post on the topic.

Dark Mode

In SwiftUI, we can implement dark mode very easily as part of our existing work. In-fact, when using default Views and Labels in SwiftUI these will work out of the box. If you are manually specifying colours, just be careful to use Color.label instead of and Color.systemBackground instead of Color.white for anything that should adapt when run with dark mode enabled.

There may be occasions where specific As you may have noticed, the existing sample app I created for Widgets didn’t specify many colours, apart from those of the Tube Lines. When overlaying text on these backgrounds, we always want to use white even in dark mode, so we can specify this manually.

Line name colour must remain the same, status text must adapt

TL;DR: Only use white and black when the colours should remain the same between dark and light modes.

Dynamic Type

As with dark mode, if we are using the default Labels in SwiftUI, we get dynamic type for free though there are a number of things that we should do to improve how it behaves when we start to implement more complex interfaces. Let’s check out how our Tube Status example works at the largest accessibility dynamic type size (AX5).

AX5 Font Size
AX5 Font Size
(Optimised for Dynamic Type)

Not too bad: since we’ve used the inbuilt SwiftUI fonts the size increases our body font from 17 to 53 points automatically. The containers get adjusted accordingly and we can read all the detailed information and see the status icon and the colour that represents the line.

However, two key bits of information have been truncated. We can no longer see the full name of the line or the status type. An experienced Londoner might be able to infer the information but this isn’t very accessible for tourists.

It would be much better to split these pieces of information to be split across multiple lines at this font-size. We can adapt this snippet from Hacking with Swift to automatically switch between a horizontal and vertical view when the user switches accessibility size. Instead of monitoring the size class, we need to check the sizeCategory.

@Environment(\.sizeCategory) private var sizeCategory

var body: some View {
    Group {
        if sizeCategory >= .accessibilityMedium {
            VStack(spacing: 0, content: content)
        } else {
            HStack(spacing: 0, content: content)

In general, horizontal grids, such as carousels are more difficult to provide dynamic type support as there is often nowhere for the text to expand into as the default is for the screen to scroll vertically.

Always test your app with different dynamic type sizes to ensure that your views don’t break if users enable this feature.


SwiftUI also provides excellent support for Voiceover straight out of the box. If you run the app with VoiceOver enabled you’ll notice that all of the elements will be read out as you navigate down the screen. This “free” implementation here is a great starting point but there are definitely things we can do to improve it.

Here, each of our text labels is classed as an individual element, which means we need to navigate through the three different elements to get to the next line status. We should combine these into a single accessibility element so that the user can navigate to the specific tube line they need much more quickly. Once they find the correct line, they can still hear each of the labels, since they are grouped.

VStack {
    LineStatusView(update: update)
    // ... etc.
.accessibilityElement(children: .combine)

However, upon combining the elements, you’ll notice that Voiceover says that the combined elements is an “image”. We can fix this by adding the following two lines.

.accessibility(addTraits: [.isStaticText])
.accessibility(removeTraits: [.isImage])

This is obviously just a quick overview of what’s possible with some of the accessibility features in SwiftUI and iOS. For further reading I’d recommend checking out Rob Whitaker‘s blog.


For iPadOS we can use exactly the same codebase as we used for iOS. There’s not a huge amount more we would want to do specifically for iPad for such a simple app. One main distinction is that we can display our app in multiple windows. Since we’re already using WindowGroup as our SwiftUI scene, we get this ability for free.

Tube Status app running in multiple windows on iPad.

 Watch

The App

Until now, all our work has been focussed on iOS and iPadOS. We will now add the additional requirement of supporting other platforms. Since all the platforms support Swift and SwiftUI, we just need to make our shared framework compile to code for each of the additional platforms so that we can reuse our views across each.

Tube Status app running on watchOS

I used this tutorial to ensure that the same Shared framework we created in the previous blog post will support all four platforms. It will mean that we can, as we did with the widget project, share all of our code relating to networking, domain models and even SwiftUI views between our iOS app and the other Apple platforms.

Once we’ve enhanced the shared framework, it’s time to create a new target for our watch app. This should be familiar from the previous tutorial: in Xcode, go to File → New → Target → watchOS → Watch App and click Next. This will create a standalone app for Apple Watch that doesn’t require our existing iOS app to be installed. As we have previously, we want to use SwiftUI and the SwiftUI lifecycle for the app: this allows us to reuse the most amount of code between platforms. Select to include Complication which we will cover below, but not Notification scene which is not relevant for our simple tube app (since it does not implement push notifications).

Setup your watchOS Target in Xcode: SwiftUI Interface, SwiftUI Lifecycle, Swift Language, Include Complication.
Setup your watchOS Target in Xcode

Next, we just need to ensure we include the Shared framework into our watch app:

Be careful to include the Shared framework in the Watch app

The watch app template will include an App declaration and a template ContentView. Since we already have a content view in our shared framework, we can delete the provided one, and simply import the shared one into the app.

import Shared
import SwiftUI

struct TubeStatusApp: App {
    @ObservedObject private var viewModel = StatusViewModel(client: .init())

    var body: some Scene {
        WindowGroup {
            ScrollableContentView(updates: viewModel.status)

One minor change, will fix the truncation showed in the screenshot above. We’ve already implemented logic for our AdaptiveStack to display vertically at higher dynamic type-sizes, but we can use this for our watch app too:

private var shouldDisplayVertically: Bool {
     #if os(iOS)
     return sizeCategory >= .accessibilityMedium
     #elseif os(watchOS)
     return true
     return false

That’s it: the app should run seamlessly on watchOS (and it looks great too!)

Tube Status app optimised for watchOS
Tube Status app optimised for watchOS
Much better!


Adding a watchOS complication isn’t too difficult. It uses a lot of similar concepts to the iOS Widget we implemented previously. However, on the Apple Watch space is much more limited so we will need to massively reduce the amount of information we can provide.

There is no support for using Intents to supply user-configurable parameters for complications. This means we will have to provide separate complication descriptor for each of the tube lines we want to support. We do this using the getComplicationDescriptors method.

func getComplicationDescriptors(handler: @escaping ([CLKComplicationDescriptor]) -> Void) {
    let descriptors = Line.allCases
        .map { $0.rawValue }
        .map {
            CLKComplicationDescriptor(identifier: $0,
                                      displayName: "\($0) Status",
                                      supportedFamilies: CLKComplicationFamily.allCases)
    // Call the handler with the currently supported complication descriptors

As with Widgets, we provide data to our complication using a TimelineEntry type. As before, for apps like public transit status which can’t provide future forecasts, we can only ever provide a single reliable timeline entry using the getCurrentTimelineEntry method.

func getCurrentTimelineEntry(for complication: CLKComplication,
                             withHandler handler: @escaping (CLKComplicationTimelineEntry?) -> Void) {
    // Use the identifier to retrieve the Line from the selected complication
    guard let line = Line(rawValue: complication.identifier) else { handler(nil); return }
    // Reuse our StatusService from the Shared framework to retrieve status data
    StatusService.getStatus(client: .init(), for: line) { [weak self] statuses in
        guard let status = statuses.first,
              let template = self?.getTemplateForLineStatusUpdate(status, matching: complication)
        else { handler(nil); return }
        // Call the async handler with the current timeline entry
        handler(CLKComplicationTimelineEntry(date: Date(), complicationTemplate: template))

For iOS Widgets our view implemented in a separate configuration type, decoupled from our WidgetKit.TimelineEntry model. In contrast the CLKComplicationTimelineEntry type for complications contains all the information needed to display our complication.

All we need to do now is to map our status information (LineStatusUpdate) into the CLKComplicationTemplate type by implementing the getTemplateForLineStatusUpdate(status: LineStatusUpdate, matching: CLKComplication) method we have used in the snippet above:

func getTemplateForLineStatusUpdate(_ update: LineStatusUpdate,
                                    matching complication: CLKComplication) -> CLKComplicationTemplate? {
let template: CLKComplicationTemplate?
    switch {
    case .modularSmall:
        template = CLKComplicationTemplateModularSmallStackImage(line1ImageProvider: imageProvider, 
                                                                 line2TextProvider: header)
    // Implement the CLKComplicationTemplate for each other 
    // supported complication format
    @unknown default:
        template = nil
    template?.tintColor = UIColor(Line.bakerloo.color)
    return template

Three methods implemented; another great feature available for our users.

watchOS Complications give our users the tube status for various lines with a quick glance.

 TV

When I was writing this section of the article my partner asked me: why would on earth would we want to display the tube status on our TV?

How about something like a large real-time display that we can check at work just before we leave the office to go home? Here’s a photo of the one we have at my day-job- not (YET) using this implementation! Or we could even use it to power the display boards at the station.

Since we’ve already done the cross-platform work to make our shared framework to run across both iOS and watchOS, adding support for the TV should be trivial:

  • Add a new target for supporting tvOS in the same way as before:
    File → New → Target → tvOS → App.
  • Implement the app declaration, we can actually use exactly the same declaration (watchOS: TubeStatusApp.swift) that we used for the watch above.
  • Build and run!
Tube Status app running on tvOS
Tube Status app running on tvOS

As an alternative, we could use the StaticContentView we implemented for our iOS Widget to display all the statuses and hide the detailed descriptions. This would be more practical if we are indeed running in a Kiosk mode.

Tube Status app running on tvOS without scroll

Clearly this is a design question, but it illustrates how the code reuse across the different platforms can give us greater flexibility in our design choices.


Finally, we come to the longest standing platform, macOS. By now, our app is pretty good at adapting to various screen-sizes and contexts.

We can add a new target for supporting macOS in the same way as before:
File → New → Target → macOS → App.

If we run the app now, we will see a blank screen and output to the console complaining of issues connecting to the Internet. This is because by default macOS apps run inside an App Sandbox, preventing access to files, networking and other system functionality such as hardware. Not to fear- enabling network connectivity for our app is as simple as ensuring the checkbox is set correctly in Signing & Capabilities for the target.

We need to ensure that Outgoings Connections are allowed for our macOS app

Run again and we should see the familiar Tube Status view:

Tube Status app running on macOS

As with all the other platforms, this should fully support Dark Mode, Voiceover, etc. when set within macOS System Preferences.

There are plenty of additional features we could implement for macOS.

In Total

There are so many further tweaks and improvements we can make, but using SwiftUI we’ve managed to very quickly add support

Overall, we’ve implemented apps that work across:

  • All four distinct Apple platforms with their individual nuances
  • VoiceOver and dynamic type
  • Quick access to information through widgets on iOS, macOS and watchOS complications
  • Both dark and light mode

Sample code for this post is available on GitHub.
Make sure to checkout the going-for-gold branch of the repository!

Enjoyed this article?
Share it to your network, and let me know what you thought!

Constructing Data with Swift Result Builders

When Apple introduced SwiftUI in 2019, they showed how Swift 5.1’s function builders could be used to quickly, and readably, build user interfaces containing a wide range of elements. In Swift 5.4 (bundled with Xcode 12.5 or later), these have been renamed “result builders” and are now a public language feature. Therefore, as developers we can readily use them ourselves when building arrays of objects in our code.

In iOS apps we often use UIAlertController to display error messages. I often see the following extension on UIViewController, allowing alerts to be easily presented throughout the app.

extension UIViewController {
    func presentAlert(title: String, message: String,
                      actions: [UIAlertAction]) {
        let alert = UIAlertController(title: title, message: message,
                                      preferredStyle: .alert)
        actions.forEach { alert.addAction($0) }
        present(alert, animated: true)

Often this results in some logic at the call site when there are alerts that change depending on the message being displayed. For example, we may want to handle an error that comes back from one of our API calls. In this case, the error may either be resolvable or not depending on its HTTP status code. If it is a resolvable error we want to give the user the option to retry.

func handleAPIError(_ error: NetworkError) {
    var actions = [UIAlertAction(title: "Cancel", style: .cancel)]
    let errorIsResolvable = (500...599).contains(error.code)
    if errorIsResolvable {
            UIAlertAction(title: "Retry", style: .default) { _ in
    navigationController?.presentAlert(title: "An Error Occurred",
                                       message: error.localizedDescription,
                                       actions: actions)

This logic isn’t too complex, but if we were to have a number of conditions or actions to append it can become messy very quickly. To prevent this, we could create a result builder for in-place of the array of actions that we were originally passing in.

This will allow us to add actions, or not, in the same way that we do when building our SwiftUI views.

public struct UIAlertActionBuilder {
    public static func buildBlock() -> [UIAlertAction] {

    public static func buildBlock(_ elements: UIAlertAction...) -> [UIAlertAction] {
        elements.compactMap { $0 }

    public static func buildBlock(_ elements: [UIAlertAction]...) -> [UIAlertAction] {
        elements.flatMap { $0 }

    public static func buildIf(_ elements: [UIAlertAction]?) -> [UIAlertAction] {
        elements ?? []
extension UIViewController {
    func presentAlert(title: String?, message: String?,
                      @UIAlertActionBuilder actions: () -> [UIAlertAction]) {
        let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
        actions().forEach { alert.addAction($0) }
        present(alert, animated: true)

Our original logic can now become much more readable (and declarative).

func handleAPIError(message: String, code: Int) {
    let errorIsResolvable = (500...599).contains(code)
    navigationController?.presentAlert(title: "An Error Occurred",
                                       message: message) {
        UIAlertAction(title: "Cancel", style: .cancel)
        if errorIsResolvable {
            UIAlertAction(title: "Retry", style: .default) { _ in

Without much change, we can even take this one step further by creating a generic ArrayBuilder. This will allow us to build arrays of any type that can be useful in all sorts of places in our codebase.

public struct ArrayBuilder<T> {
    public static func buildBlock() -> [T] {
    // ... etc.

We can also implement the methods for buildEither so that we can support else branches when building arrays.

public static func buildEither(first: [T]) -> [T] {

public static func buildEither(second: [T]) -> [T] {

In order to use this new ArrayBuilder in place of our UIAlertActionBuilder.
We would simply use the following snippet.

func presentAlert(title: String?, message: String?,
                  @ArrayBuilder<UIAlertAction> actions: () -> [UIAlertAction])

As you can see, result builders can be an invaluable tool to help create lists of data cleanly in Swift. There are often places in our apps where elements may or may not appear.

It’s helped me to massively reduce the amount of code needed, for example in Settings menus, for some of my apps: where certain settings are shown or hidden depending on others and the profile of the user who views the page.

Get in touch?

Building (almost) anything on Bitrise using Docker

Bitrise is gaining a lot of users in the mobile development community- but did you know you can also use it as a CI tool for non-mobile projects too?

For Little Journey we use Bitrise to build our full stack of applications including front-end (Angular) and back-end (Vapor) web. The web applications are both deployed to a Linode server.

Docker 18.09 came with a new tool called BuildKit which allows you to export executables built inside a container so that they can be deployed directly on the target platform.

DOCKER_BUILDKIT=1 docker build --output type=tar,dest=release.tar .

By setting the DOCKER_BUILDKIT variable, we can output a tarfile containing the build artifacts we need, such as executables or compiled code.

In order to do this, we need to create a Dockerfile with a multi-stage (two stages) build. The first stage will install any dependencies and run the build. The second stage copies our build files into a clean container so that we can export just the build files that we need, rather than the whole codebase.

FROM swift:xenial AS build-stage
COPY . .
RUN apt-get -qq update && apt-get install -yq libssl-dev libicu-dev
RUN swift build -c release

FROM scratch AS export-stage
# Vapor Swift stores build files in .build/release
COPY --from=build-stage /root/.build/release /

For our front-end Angular app, the deployment is now as simple as transferring this tar file to the relevant folder on our Linode server and decompressing it by running tar -xvf release.tar from the command line.

For our Vapor API, we can ensure that the executable is built in a container that matches our server (Ubuntu 16.04 LTS) so that it will run correctly when deployed to the server, even though we are building it using a macOS agent on Bitrise.

Docker is also great for running our tests so that we can be sure they all pass before each pull request gets merged into our main codebase.

Multi-stage Docker builds are also great for doing this. We can add a test-stage between our initial setup / build and export stages.

If required, it’s also possible to add additional phases for different release environments (such as pre-production) environments if different build configurations are required.

# Create a Lightweight Node environment with our 
# dependencies to use as a base container
FROM timbru31/node-alpine-firefox AS base
COPY . .
# Skip Chromium download as we use Firefox for testing
RUN npm config set puppeteer_skip_chromium_download true -g
# Install our dependencies
RUN npm install

# Create a test container (on top of base), set path to Firefox
# Run lint to ensure code-style and run the unit tests
FROM base AS test
ENV FIREFOX_BIN=/usr/bin/firefox
RUN npm run-script lint && npm test

# Create a build container (on top of base) and run the build
FROM base AS prod
RUN npm run-script build-prod

# Create an empty container copying the output
FROM scratch AS build-prod
COPY --from=prod /dist/little-journey /

We can now pass a stage target parameter into Docker to either

  • run the tests for pull requests:
    docker build --target test .
  • build an executable on code-merge:
    DOCKER_BUILDKIT=1 docker build --output type=tar,dest=release.tar --target build-beta .

Want to know more?

I’d recommend this article from @ZachSimone on how to deploy a Vapor app to a Linode Ubuntu server.

Check out the full documentation on Docker BuildKit and Bitrise.

We use these techniques for building our front-end (Admin Panel) and back-end web applications at Little Journey. Little Journey is an interactive, virtual reality (VR) mobile app designed to prepare children aged 3 to 12 years for day-case surgery.