CarPlay: Linking to the Maps App

Simon Rice — Sun, 18 Oct 2020 14:28:52 +0000

I've recently been granted a CarPlay developer entitlement from Apple 🎉 and as a result been working on a little app for this platform. On first impression, its development platform has shades of legacy WatchKit development due to the heavy reliance of adding views (or, in this instance, populated templates) to an "interface controller", except without any use of Interface Builder, and definitely no form of SwiftUI at the time of writing! Indeed the best way of seeing CarPlay is like a second display for your app the provides a very specific set of functionality - that in itself sounds a lot like the early days of Apple Watch!

When being granted your CarPlay entitlement, you get pointed to two resources:

From my experience, combined together these give an extensive guide to developing on CarPlay. However, I've noticed a small omission that I'd like to write about.

One template for CarPlay I've been using is the Point of Interest template (CPPointOfInterestTemplate), for which there literally is a point of interest about this template in the WWDC video:

When a location is selected from a list, you may choose to show a secondary card for that point, revealing additional information and up to two buttons.

These buttons could be used for a variety of tasks. For instance, they may signal you to switch to a navigation app for driving directions or push to another template to display additional information for that location.

Now interestingly neither the video nor the programming guide state how to switch to a navigation app!

CPPointOfInterest has 2x optional properties relating to buttons that show up when you have a secondary card displayed - primaryButton and secondaryButton. These are both of type CPTextButton. In CPTextButton's initialiser, there's a handler parameter that takes a closure. But what should go there if you want to open the point up on your maps app so you can route to that location?

Now chances are you already have an MKMapItem since CPPointOfInterest requires one in its initialiser. This class has a method of interest, specifically openInMaps - this sounds very promising.

So let's try it out:



let mapItem = MKMapItem(placemark: ...)
let poi = CPPointOfInterest(
    location: mapItem,
    title: "Sample Location",
    subtitle: "Subtitle",
    summary: "Summary",
    detailTitle: "Detail Title",
    detailSubtitle: "Detail subtitle",
    detailSummary: "Detail Summary",
    pinImage: UIImage()
)

poi.primaryButton = CPTextButton(
    title: "GO",
    textStyle: .normal,
    handler: { _ in item.openInMaps() }
)

let mapTemplate = CPPointOfInterestTemplate(
    title: "Locations", 
    pointsOfInterest: [poi], 
    selectedIndex: NSNotFound
)

The template will now show one location...

...and you can drill down to the location in question...

...tapping "GO" will open up the maps app - unfortunately this happens on your phone - and crucially Apple will reject your app because Apple rightly states:

All CarPlay user flows must be possible without interacting with iPhone.

Thankfully this can be fixed - MKMapItem.openInMaps(...) can optionally take a few parameters:

launchOptions - there are a few optional launch parameters you can pass to the maps app to help with directions. More on this a bit later.
scene - the scene that you're launching the maps app from.
completion - an optional completion handler that is called upon the maps app being loaded.

Now the scene parameter looks promising. Chances are you'll be calling all of this from CPTemplateApplicationSceneDelegate.templateApplicationScene(:didConnect:), which has a CPTemplateApplicationScene parameter. Conveniently this is a UIScene subclass, so you can either pass this directly in or retain it from your didConnect method.

So let's now populate that scene parameter - again assuming this is called from didConnect:



poi.primaryButton = CPTextButton(
    title: "GO",
    textStyle: .normal,
    handler: { _ in 
        item.openInMaps(
            from: templateApplicationScene
        ) 
    }
)

This indeed opens up the maps app with the suggested location prepopulated. However, as of iOS 14.0.1, your own app will almost certainly crash shortly afterwards with a system stack trace that looks something like this:

The best way to stop this happening is to provide an empty completionHandler parameter:



poi.primaryButton = CPTextButton(
    title: "GO",
    textStyle: .normal,
    handler: { _ in 
        item.openInMaps(
            from: templateApplicationScene,
            completionHandler: { _ in return }
        ) 
    }
)

And now the external maps app opens on your CarPlay display with your location prepopulated, but this time without any crashes on your app.

Note about the CarPlay external display on the iOS simulator: annoyingly there is no maps app on the CarPlay display on the simulator. Opening the link opens a "Now Playing" display, as shown below. This in turn explains why I have no further screenshots of the maps app experience from here.

Now I did mention MKMapItem.openInMaps(...) had a launchOptions parameter. Given that you already have a destination prepopulated and it's also a car routing, no parameters need passing here - therefore launchOptions can be left out.

I would however suggest populating 2x additional properties of your MKMapItem instance to give the maps app some extra information:

name - this shows up as the name of the location. Chances are you'll know this in some way. If you leave this out, the maps app will name the location "Unknown Location", which isn't desirable.
pointOfInterestCategory - this is more for future-proofing than a necessity if you have this information at hand - it might help the maps app hook into any additional functionality for this specific location.

Finally, you may be applying a button like this from a different kind of template, such as CPInformationTemplate - again, as long as you have the location that you wish to navigate to, creating a map item only requires an MKPlacemark instance, which only requires the location in question to initialise.

Swift on Netlify

Simon Rice — Fri, 15 May 2020 20:10:47 +0000

Since it was open sourced in December 2015, there have been a number of efforts in bringing Apple's Swift Programming Language to run on a variety of operating systems, servers and even embedded systems.

In December 2019, prominent Swift & iOS developer John Sundell open sourced Publish, a production-ready static site generator package written in Swift. Its purpose is given a set of markdown and Swift files, you can generate your HTML and other assets by running swift run - this will fetch your Swift Package Manager (or SPM) dependencies, build a command line app and run it, putting your generated website in a directory (which, by default, is Output).

Since I’m primarily an iOS developer by trade who previously tended to opt for Ruby / Middleman to publish content on the web, and given I’ve used Netlify for hosting said websites, I had a lightbulb moment 💡 What if I could get Swift working with full SPM caching on Netlify, and so allow a seamless build pipeline for Publish? After all, Netlify’s build image is open source & is welcoming contributions.

Well, I'm happy to say not only is it possible, but as of build image v3.3.8, Swift is now supported on Netlify as a first party language.

How to create a static website written in Swift that’s hosted on Netlify

Build your website using Publish locally, and ensure you’ve checked in your Package.swift file.
After pushing your website to a remote repository, set it up on Netlify.
When prompted on Netlify for your Basic Build Settings (or in Your Site’s Settings -> Build & Deploy -> Continuous Deployment -> Build Settings if you're migrating an existing website), use these settings to deploy your website:

Build Command: swift run
Publish Directory: Output

...and then deploy 🚀 that’s all there is to it 🎉

Note that your first deploy will be a bit slower as there’s no SPM cache to start off with, but this will be used for subsequent builds.

Optional, but recommended: Include a .swift-version file in the root of your repository stating which version of Swift you’re targeting. By default, Netlify runs on Swift 5.2, which at the time of writing is the current, readily-available stable version - even if you are using Swift 5.2 yourself, including this file is a good habit. However, Netlify supports any version of Swift from 5.0 and above that swiftenv supports. If you’re not using Netlify’s default version of Swift then, in addition to your SPM dependencies, your Swift version will also be cached at the end of your first build, so your build time isn’t sucked up downloading your selected version of Swift. You can equally configure a SWIFT_VERSION environment variable on Netlify, but if you have swiftenv installed locally then a .swift-version file will work for you locally too.

While Publish is currently the most popular static site generator that’s written in Swift, in practice Netlify can run any SPM-based Swift command line app that generates content of some form, so long as it’s not dependant on any proprietary framework from Apple (such as UIKit or AppKit). You just need to ensure your publish directory is pointing to the right place.

I’ve enjoyed playing a small role in bringing the Swift Programming Language to another new environment, via a small bit of Docker & shell scripting that I might document on here if anyone’s interested. And if Swift is your thing, I hope you find this little guide useful.

Forem: Simon Rice

CarPlay: Linking to the Maps App

Swift on Netlify

How to create a static website written in Swift that’s hosted on Netlify