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

Benefits

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!

Deployment

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.

Conclusion

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.

Why?

Web

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

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.

How?

Backend

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": "https://www.oliverbinns.co.uk/2020/09/05/going-for-gold-taking-full-advantage-of-apple-platforms/",
        "title": {
            "rendered": "Going for Gold- Taking full advantage of Apple Platforms"
        },
        "content": {
            "rendered": "
                <p class=\"has-drop-cap\">
                    In a recently published <a href=\"https://www.oliverbinns.co.uk/2020/06/27/create-a-tube-status-home-screen-widget-for-ios-14/\">
                    blog-post on building widgets for iOS 14
                </a>
                ..."
        }
    }
]

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)
}

ViewBuilder

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.

@ViewBuilder
func viewForContent(_ content: PostContent) -> some View {
    switch content {
    case .heading1(let string):
        Text(string).font(.title)
    case .heading2(let string):
        Text(string).font(.title2)
    case .horizontalRule:
        Divider()
    // 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.

Paragraphs

Overview

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!

Decoding

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.

Rendering

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 {
        UITextView()
    }

    func updateUIView(_ uiView: UITextView, 
                      context: UIViewRepresentableContext<Self>) {
        uiView.isEditable = false
        guard let attributedString = attributedString else {
            return
        }
        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 {
        UITextView()
    }

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

        DispatchQueue.main.async {
            let size = uiView.intrinsicContentSize
            guard size.height != self.desiredHeight else { 
                return
            }
            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!

iOS

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 Color.black 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.

Text(update.line.displayName)
    .foregroundColor(.white)
    .padding()
    .background(update.line.color)
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.

Voiceover

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.


iPadOS

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

@main
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
     #else
     return false
     #endif
}

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!

Complication

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
    handler(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 complication.family {
    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.

macOS

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 {
        actions.append(
            UIAlertAction(title: "Retry", style: .default) { _ in
                retryRequest()
            }
        )
    }
    
    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.

@resultBuilder
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
                retryRequest()
            }
        }
    }
}

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.

@resultBuilder
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] {
    first
}

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

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?

Create a Tube Status home-screen Widget for iOS 14

One of iOS 14’s most exciting changes for both users and developers will undoubtedly be it’s addition of widgets for quick access to information directly from the home-screen without having to open the app. This type of functionality has previously been limited to just two first-party applications (Calendar and Clock).

London Underground status home-screen widgets on iOS 14

In this article, I will detail how to quickly and easily create a home-screen widget for your app, using the London Underground status board as a real-world example. Transport for London provides a free-to-use Open API (https://api.tfl.gov.uk) we can easily utilise that will allow us to get up-to-date status for all its services.

Sample code for the project is available on GitHub:


Getting Started

Requirements

Developing for iOS 14 requires Xcode 12. Xcode 12 will run on any Mac which is running either macOS 10.15 (Catalina) or macOS 11.0 (Big Sur). You can download it from the beta software tab on the Apple Developer Downloads page: https://developer.apple.com/download/

PSA: iOS 14 is currently in early beta.
Do not install it on your main device, especially one you rely on.

You can run widgets in the simulator, but to take full advantage of this tutorial, including supporting multiple widgets and intents it’s best to have a device running iOS 14.

Project Setup

Widgets cannot be provided standalone, so we will need to start with a boilerplate app. Here we will setup a new Xcode project and produce a basic app. If you are a seasoned app developer, you may want to skip to the “Your First Widget” section.

In order to get started, let’s select “Create a new Xcode project” from the Xcode launch screen. Select app, then next.

Xcode 12 Launch window

WidgetKit requires “SwiftUI” as the interface so we will use this for our app too.

  • Enter a name for your project
  • Enter your own name, or company name under “Organization Identifier”.
  • Select “SwiftUI” to use for the “Interface”
  • Use “SwiftUI App” as the Lifecycle
  • Use “Swift” as the language.

This article won’t go into detail about how to test your app, but feel free to leave the “Include Tests” box checked.

Then, finally, choose a location to store your app on your Mac.
Xcode will generate an app template containing YourProjectApp.swift.

Architecture

In order to share code between the main-app and widget, we can create a shared framework in Xcode. This isn’t completely necessary for a simple app such as this, but it’s good practice as you may want to share logic further if you are implementing other features such as Siri Shortcuts or iMessage apps.

Architecture of London Underground app

Create a new framework in Xcode, go to File → New → Target… and select Framework. Some common product names for shared frameworks are “Core” or “Shared”. From now on, it’s easiest to create all new source files within this new shared framework target.

Model

We need to create a model to represent our data. Using Swift’s Codable protocol we can automatically decode the JSON response from the TfL API.

public struct LineStatusUpdate: Identifiable, Decodable {
    enum CodingKeys: String, CodingKey {
        case id
        case line = "name"
        case statuses = "lineStatuses"
    }
    public let id: String
    let line: Line
    let statuses: [StatusUpdate]
}

In order to keep our variable names “Swifty”, we can use coding keys to map from the response that the API returns:

{
    id: "bakerloo",
    name: "Bakerloo",
    lineStatuses: [ ... ]
}

The full model used to build the app can be found in the sample code, linked at the bottom of this article.

Networking

We can implement a NetworkClient to handle our API calls. We will use URLSession from the Foundation library to do this.

import Foundation

public final class NetworkClient {
    private let session: URLSession = .shared

    enum NetworkError: Error {
        case noData
    }

    func executeRequest(request: URLRequest, completion: @escaping (Result<Data, Error>) -> Void) {
        session.dataTask(with: request) { (data, response, error) in
            if let error = error {
                completion(.failure(error))
                return
            }
            guard let data = data else {
                completion(.failure(NetworkError.noData))
                return
            }
            completion(.success(data))
        }.resume()
    }
}

Create a new service to call the NetworkClient and decode the API data into the model we implemented earlier.

import Foundation

public struct StatusService {
    public static func getStatus(client: NetworkClient, completion: (([LineStatusUpdate]) -> Void)? = nil) {
        runStatusRequest(.lineStatus, on: client, completion: completion)
    }

    private static func runStatusRequest(_ request: URLRequest,
                                         on client: NetworkClient,
                                         completion: (([LineStatusUpdate]) -> Void)? = nil) {
        client.executeRequest(request: request) { result in
            switch result {
            case .success(let data):
                let decoder = JSONDecoder()
                do {
                    let lineStatus = try decoder.decode([LineStatusUpdate].self, from: data)
                    completion?(lineStatus)
                } catch {
                    print(error.localizedDescription)
                }
            case .failure(let error):
                print(error.localizedDescription)
            }
        }
    }
}

Views

SwiftUI is great for quickly creating user interfaces for your application.
The app template will already include a ContentView, but we can create new views within the shared framework. As long as we declare that these views are public, they will be accessible from both the application and (later on!) our widget extension.

public struct LineStatusView: View {
    let update: LineStatusUpdate
    var body: some View {
        HStack {
            Text(update.line.displayName)
                .font(.subheadline)
                .fontWeight(.medium)
                .padding()
                .background(update.line.color)
            if let status = update.statuses.first {
                Text(status.type.rawValue)
                    .font(.subheadline)
                    .padding()
            }
        }
    }
}

This code creates a view showing the name of the tube line and the first status that is returned by the API.

Make sure to import the shared framework at the top of the file when you want to use this new view.

import Shared

LineStatusView(update: update)

You can use this new view in the content view of your app to display the status of each of the lines when the app is opened. Now we have a simple working app, we can look at displaying the view on the home-screen too!


Your First Widget

Create the Target

Let’s begin implementing our widget. First, we need to create a new target. In Xcode, go to File → New → Target… and then select the Widget Extension template. Enter a name for your Widget and uncheck “Include Configuration Intent”- we will not need this for our first, basic widget.

Xcode has now created a template widget for us. There are boilerplate implementations of TimelineProviderTimelineEntry and Widget that we can add our implementation to. From now on, create the new source files within the newly created widget folder.

Timeline Provider & Timeline Entry

The timeline provider works on a similar concept to CLKComplicationDataSource which is used for creating complications for the Apple Watch. We can provide an array of data entries from the current time into the future. This is useful for apps, such as the weather app which can provide entries for future forecasts in one go, reducing amount of refreshes that are needed. For our transport status app, we are obviously unable to predict future disruption so we will only provide one entry- the current status.

The TimelineEntry for our status update can use the models from our shared library that we created above:

struct StatusUpdateEntry: TimelineEntry {
    let date: Date?
    let updates: [LineStatusUpdate]
}

The TimelineProvider protocol requires us to implement two methods:

The snapshot method is called when we need to provide a short-lived display of our widget, such as from the widget selection menu. The Apple documentation suggests that sample data is used here, if required, to allow the snapshot to return as quickly as possible.

The timeline method is called when the widget is being displayed normally, on the home-screen of the device. We need to return a timeline of entries. In our transport status example, we are only able to return a single entry. We can set the expiry date of the timeline to be two minutes into the future so that we are regularly refreshing the widget with the latest up-to-date information.

public func timeline(with context: Context,
                     completion: @escaping (Timeline<Entry>) -> ()) {
    // Fetch the latest travel information from the API
    StatusService.getStatus(client: NetworkClient()) { updates in
        let entry = SimpleEntry(date: Date(), updates: updates)
        // Refresh the data every two minutes:
        let expiryDate = Calendar
            .current.date(byAdding: .minute, value: 2, 
                          to: Date()) ?? Date()
        let timeline = Timeline(entries: [entry], 
                                policy: .after(expiryDate))
        completion(timeline)
    }
}

Widget

The widget implementation uses the @main property wrapper, new in Swift 5.3, to mark it as the entry point to our widget.

We provide a WidgetConfiguration as the body for this. The widget configuration requires a placeholder view, which is displayed while our widget is loading, and the timeline provider we discussed above.

We can use modifiers to specify name and description that will be shown to the user when they are selecting a widget to add to their home-screen. We can also specify which widget sizes we support. In the case of our Tube Status widget, as it will contain quite a lot of information, we should add .supportedFamilies([.systemLarge]).

We build the view inside the widget configuration in the same way as we build our WindowGroup in the main app.

struct AllLinesWidget: Widget {
    public var body: some WidgetConfiguration {
        StaticConfiguration(kind: "All Lines",
                            provider: AllLinesProvider(),
                            placeholder: AllLinesPlaceholderView()) { entry in
            ContentView(updates: entry.updates)
        }
        .configurationDisplayName("Tube Status")
        .description("See the status board for all underground lines")
        .supportedFamilies([.systemLarge])
    }
}

Multiple Widgets

Widget Bundle

We can provide multiple types of widget using the WidgetBundle protocol. This is fairly simple to use, we can just build our group of widgets in the same way we build a SwiftUI view.

@main
struct TubeWidgets: WidgetBundle {
    @WidgetBundleBuilder
    var body: some Widget {
        AllLinesWidget()
    }
}

When you add main here, make sure you remove it from the widget itself- otherwise the Swift compiler won’t be able to work out which is the correct entry-point for our app.

We can add as many different types of widget as we like here:

var body: some Widget {
    MyFirstWidget()
    MySecondWidget()
    MyThirdWidget()
}

Providing Customisation

Intents

The above example works well if we want to display status information for all lines, but what if our user only travels on one particular line? We could create a new widget for each line, but this quickly becomes messy and our widget selection menu would require the user to swipe through a lot of lines to find the one that they are interested in. And what about if we wanted to also provide widgets for buses, DLR and other transport modes?

Using Intents to select a Tube Line

We can use Intents to allow the user to configure a single widget for the line they want to see. Using WidgetBundles, we can keep our original status widget and implement an additional widget using an intent with IntentTimelineProvider.

Let’s start by creating the Intent. If you have implemented something using Siri Shortcuts before, you will likely already be familar with intents.

Create a new intent definition file: File → New → File → SiriKit Intent Definition File. Ensure that this file is included in both the app target and the widget extension.

We can create a new enum datatype to hold the different Line options:

Create an enum for the different Tube line options using the visual editor

The unknown case is not displayed in the picker, but we can use it later for specifying a default value.

Next we need to create a new Custom Intent:
Add a title and description so that the user knows what they are choosing.
The Intent needs to be eligible for widgets, but Siri Shortcuts and Suggestions are not needed for this.

Create a custom intent to allow the user to select a Line for the widget

We also need to declare the intent in the application’sInfo.plist file, otherwise it won’t be able to load in the “Edit Widget” modal.

<key>NSUserActivityTypes</key>
<array>
    <string>LineSelectionIntent</string>
</array>

Intent Timeline Provider

In order to support intents, we need to conform our timeline provider to IntentTimelineProvider rather than TimelineProvider. This protocol is very similar but passes the intent into snapshot and timeline methods.

We can use this intent parameter to retrieve the user parameters that have been specified.

public func snapshot(for configuration: LineSelectionIntent,
                     with context: Context,
                     completion: @escaping (SimpleEntry) -> () {
    let line = self.line(for: configuration)
    StatusService.getStatus(client: NetworkClient(), for: line) {
        let entry = LineStatusUpdateEntry(date: Date(), 
                                          line: line,
                                          updates: updates)
        completion(entry)
    }
}

A simple line method will be able to map from the autogenerated Intent enum to the Line enum in our model:

func line(for configuration: LineSelectionIntent) -> Line {
    switch configuration.line {
        case .circle:
            return .circle
        case .district:
            return .district
        ...
    }
}

Intent Configuration

We can now set up our new widget with an IntentConfiguration. This is similar to the WidgetConfiguration we have used previously but requires us to specify the Intent type.

struct SingleLineWidget: Widget {
    public var body: some WidgetConfiguration {
        IntentConfiguration(kind: "Single Line",
                            intent: LineSelectionIntent.self,
                            provider: SingleLineProvider(),
                            placeholder: SingleLinePlaceholderView()) { entry in
            ...
        }
        .configurationDisplayName("Line Status")
        .description("See the status for a specific London Underground line")
        .supportedFamilies([.systemSmall, .systemMedium])
    }
}

More Resources

Sample code available on GitHub:

Other information:

If you enjoyed this article, please do let me know- this is the first technical blog post I’ve ever written so I’d love to receive some feedback!