Blog.MosheBerman

Your App’s Layout and Localization APIs

2017-08-23T14:45:00-04:00

Let’s discuss five techniques for dealing with right-to-left layout across Apple platforms, using 11 different APIs. Be sure to check out the handy dandy chart at the end, and Apple’s Building Apps for the World webpage. Let’s get started, in order of oldest API to newest.

Inference By Writing Direction using NSLocale

The first technique is inferring the device’s direction, using two class methods on NSLocale. characterDirection(forLanguage:) and lineDirection(forLanguage:) take an ISO language code, such as en-US or he-IL and return a direction. You can get a valid value to pass into these methods from NSLocale’s languageCode property.

These class methods are supported as far back as iOS 4.0 and are safe to use in app extensions. They also exist on other Apple platforms: macOS 10.6, tvOS 9.0, and watchOS 2.0. I wouldn’t base the majority of my app’s layout on it, but it’s certainly useful to have them in your toolkit.

It’s also notable that, unlike the other APIs mentioned here, these methods can return top-to-bottom and bottom-to-top, besides for the expected left-to-right and right-to-left values. English, for example, has a character direction of left-to-right and line direction of top-to-bottom.

In my experiments with Xcode Playgrounds, I did not find any macOS languages that assigned a line direction that wasn’t top-to-bottom.

Explicit Layout Direction with UIApplication & NSApplication

The second technique is to reference UIApplication’s userInterfaceLayoutDirection property. This is probably the earliest API explicitly for view layout. Available since iOS 5.0, this property determines the general direction of the app. NSApplication has this property, too, as of macOS 10.6.

On both platforms, userInterfaceLayoutDirection is either .rightToLeft or .leftToRight, based on the user’s systemwide preferences. The catch here is that since this property is accessible on a sharedApplication instance, it won’t work in app extensions.

Another Writing Direction Trick, with NSParagraphStyle

NSParagraphStyle gives us another way to check for the default text layout direction. defaultWritingDirectionForLanguage(_:) takes an ISO language code, and returns one of three NSWritingDirection values: .natural, .leftToRight, or .rightToLeft. This was added to iOS 6 with a slew of typesetting improvements, and was around on macOS since 10.2. You can override the writing direction of an NSMutableParagraphStyle instance by setting its baseWritingDirection yourself.

UIView & NSView Semantic Content Attributes watchOS

Next up is UIView’s userInterfaceLayoutDirection(for attribute:) method. Added in iOS 9, you can use this to check the layout direction on a specific view or control. You can set the semanticContentAttribute manually, to force specific views to defy the rest of your app’s layout. You can use values such as .forceLeftToRight and .forceRightToLeft. The documentation says you should use this API for media playback controls. Another use case might be providing a manual language override for your app. (Really, though, just localize properly.)

There is a similar property on NSView called userInterfaceLayoutDirection. You can set it to an NSUserInterfaceLayoutDirection value: .leftToRight or .rightToLeft. WKInterfaceControl has a setSemanticContentAttribute(_:) method for watchOS 2.1 to set (but not get) the semantic content attributes.

The Modern Approach: UITraitCollection

Finally, there’s UITraitCollection, which was added in iOS 8 to help deal with the wide variety of screen resolutions stemming from all of the iOS device screen resolutions and orientations. Trait collections added a property in iOS 10 called layoutDirection. Since every UIView conforms to UITraitEnvironment, you can access this property on any UIView on iOS 10 or higher.

So there you have it. Five techniques to get and set layout direction on iOS, macOS, tvOS, and watchOS. Oh, here’s the chart:

Class	Method	Version Added
`NSLocale`	`characterDirection(forLanguage:)`	iOS 4, macOS 10.6, tvOS 9, watchOS 2
`NSLocale`	`lineDirection(forLanguage:)`	iOS 4, macOS 10.6, tvOS 9.0, watchOS 2
`UIApplication`	`userInterfaceLayoutDirection`	iOS 5, tvOS 9
`NSApplication`	`userInterfaceLayoutDirection`	macOS 10.6
`NSParagraphStyle`	`defaultWritingDirectionForLanguage(_:)`	iOS 6, macOS 10.2, tvOS 9, watchOS 2
`NSParagraphStyle`	`baseWritingDirection`	iOS 6, macOS 10.2, tvOS 9, watchOS 2
`UIView`	`userInterfaceLayoutDirection(for attribute:)`	iOS 9, tvOS 9
`UIView`	`semanticContentAttribute`	iOS 9, tvOS 9
`NSView`	`userInterfaceLayoutDirection`	macOS 10.6
`WKInterfaceControl`	`setSemanticContentAttribute(_:)`	iOS 8.2, watchOS 2.1
`UITraitCollection`	`layoutDirection`	iOS 10, tvOS 10

In case you missed the link above, here’s a link to download the bonus playground.

Learning Machine Learning with CoreML

2017-08-19T22:00:00-04:00

CoreML

This post is my notes collected while watching Apple’s WWDC 2017 Session 703, “Introducing Core ML” and Session 710, “Core ML in Depth.”

Introducing CoreML

Apple Uses

Photos: People & Scence Recognition
Keyboard: Next word prediction, smart responses
Watch: Smart responses & handwriting recognition

Examples:

Real Time Image recognition
Text prediction
Entity recognition
Handwriting recognition
Style transfer
Sentiment analysis
Search ranking
Machine translation
Image captioning
Personalization
Face detection
Emotion detection
Speaker identification
Music tagging
Text summarization

Whoa, that’s lot of examples.

Example

Recognizing a rose:

Start by color
Try shape
… It gets complicated fast

Rather than describing how a rose looks like programatically, we will describe rose emperically.

– Gaurav Kapoor

Two Steps to Machine Learning

Training
Inference

Training a Model

Collect sample data (“roses, sunflowers, lillies”)
Pass through a learning algorithm
Generate a model

Inference

Pass an image into the model
Get back a result and confidence level.

Challenges:

Prove correctness
Performance
Energy Efficiency

Three frameworks: Vision & NLP sit on top of CoreML.

CoreML is built on top of Accelerate and MPS.

Domain agnostic
Inputs: Images, text, dictionaries, raw number.
Accelerate is good for math functionality.

Advantages to Running Locally

Privacy
Data Cost
No server cost
Always available

Real Time Image Recognition

No latency

Overview

Xcode integrations

Models

A model is a function that “happens to be learned from data.” Each takes an input and gives a an output.

Neural Network Types:

Feed Forward Neural Networks (image/video)
Convolutional Neural Networks
Recurrent Neural Networks (text based applications)
Tree Ensembles
Support Vector Machines
Generalized Linear Models

Focus on the use-case and let CoreML handle the details. Models are single documents.

Inputs, types, outputs
Structure of neural network
training parameters

Where do models come from?

Developer.apple.com has some ready-to-use models.
The machine learning community: – Caffe – Keras – dmlc XGBoost – scikit learn – turi – libsvm

For converting data to CoreML format, use Apple Core ML Tools Python package.

Development Flow

Collect data
Train model
Drag model into Xcode.

Xcode shows name, filesize, author, license, inputs and outputs. It also generates Swift code asynchronously, for loading and predicting against the model.

Model sizes: How does compression work?
Type of file is abstracted.
Strongly typed inputs.

Generated Source

Input, output, and classifier classes.
Offers access to the underlying MLModel for programatic access.
MLModel has an MLModelDescription and another conformance-based (?) prediction method.
MLModel is JSON based.

Core ML Depth

CoreML provides a functional abstraction for machine learning models.

Types of CoreML Inputs

Numeric: Double, Int64
Categories: String, Int64
Images: CVPixelBuffer
Arrays: MLMultiArray (New type - why?)
Dictionaries: [String: Double], [Int64: Double]

Working With Text

Sentiment analysis example: Takes text and passes to the model and the model returns an emoji (happy/ok/sad.)

Approach: Operates as word counts.
NSLinguisticTagger to tokenize and count words
A “Pipeline Classifier” does a few things before returning a prediction. Takes a dictionary, returns a sentiment label, and sentiment scores between 0 and 1.

Modernizing MBCalendarKit

2017-08-18T09:00:00-04:00

MBCalendarKit was written in 2013, to emulate the original iPhone’s calendar app. It featured the classic grid/month view, a week view, and a day view. All three modes had a table below below the calendar, listing events for the currently selected day.

When iOS 7 brought a new calendar app to iOS, MBCalendarKit was quickly left in the past. I was slow to adopt iOS 6 technologies in this project, which made it harder to keep up. Issues began to pile up on GitHub. Swift came out, and many new calendar libraries sprung up to take MBCalendarKit’s place.

Recently, I starting woring on some features that needed a calendar UI. I looked around but found that the libraries that were simple to integrate were difficult to customize. The easily customizable ones had inneccassible documentation. I took another look at MBCalendarKit and set out to modernize it.

I’m proud to announce a nearly complete rewrite, MBCalendarKit 5, with these great new features:

Integration into your project as a dynamic framework
Swift interoperability improvements
Autolayout support
Custom Cell Support
Rendering in Interface Builder as an IBDesignable
Enhanced support for localization. Specifically, appropriate layout in right-to-left environments
An updated sample app to try out different parts of the framework
Thorough Documentation
An updated changelog

This update resolved roughly half of the oustanding issues and leads to a place where the library can stand on its own again, as a first-class software library. I have a lot going on right now, but I also have a lot on the roadmap for MBCalendarKit. I hope you like it.

Altering Git History

2017-07-26T09:00:00-04:00

The Problem

I have a personal project that I want to publish on GitHub without sensitive data, while preserving the rest of my code and my commit history. Although the project itself is long dead and its passwords are useless, there are personal email addresses, and API keys that shouldn’t be published.

Two Approaches

Initial Approach: Since I’m moving the code to a new repository, I could just copy the files, sanitize them by hand, and push a single “initial commit” to the public repository.
Alternate Approach: I can try to sanitize my repository by altering my git history.

The initial approach accomplishes my objective to publish the code without the sensitive parts, but won’t preserve commit history. Let’s investigate the alternate approach.

An Alternate Approach

The native way is a git command called git-filter-branch, used to run filters on git trees. This command is available wherever git is installed, but the documentation actually suggests a tool called BFG Repo-Cleaner for what I want to do here, so let’s look at that.

Judging by its documentation, BFG is simpler to use than git-filter-branch. BFG provides an easy way to filter strings and files from your commit history without having to write scripts yourself.

Altering History

With a tool in hand, let’s give this a try. Here’s how I did it:

Before using BFG to clean up the project history, I had to put the repo’s latest commit into my desired state. (With filtering already done.) Use a standard git clone or git pull to ensure the latest content, then make those changes.
Once the changes are made, commited, and pushed back to the git server, check out a “mirror copy” of the repository, using the --mirror flag: git clone --mirror {repo_url}
Finally, it’s time to run BFG: java -jar ~/path/to/bfg.jar --replace-text {text_file_name.txt} {repo.git}. The file {text_file_name.txt} contains strings to redact, each on its own line. (See below.)
Finally, push the contents of repo_name.git back to the server:

$> cd repo_name.git
$> git push

Notes

Bare vs Mirror

A “bare” copy is your repository containing its git state, but without your actual source files. Think of this as the contents of {repo_name}/.git in {repo_name}.
A “mirror” copy includes whatever --bare does, plus some extra information. (Following the BFG documentation, used --mirror.)

Customizing Text Replacements

The file passed into --replace-text may look like this:

password
someAPIKey123
aUsernameABC

By default, each string is replaced with ***REPLACED***. According to BFG’s author, you can customize replacements by adding an arrow and the replacement string, like so:

password==>***REDACTED***
someAPIKey123==>{api_key}
aUsernameABS==>

Removing Files

Remove files with:

$> java -jar ~/path/to/bfg.jar --delete-files {file_names} {repo_name.git}

Sanity Check

Double check your work by comparing any commits where a redacted string was modified or introduced. If you see the replacement strings, you’re all set.

Vision

2017-07-04T00:00:00-04:00

These are my notes on WWDC 2017 Session 506, called “Vision Framework: Building on Core ML.” I’ve linked to Wikipedia technical terms that I wasn’t familiar with.

What is it?

High-level on-device solutions to computer vision problems through one simple API.

– Brett Keating, WWDC 2017

What can it do?

Vision framework can detect faces, based on deep learning. Apple says this gives higher precision and higher recall than previous technologies, such as Core Image or AVCapture. This allows for better detection of smaller faces, side views (“strong profiles,”) partially blocked (“occluded”) faces, “including hats and glasses.”

The full feature list:

Face landmarks, a “constellation of points” on the face. Essentially, tracing eyes, nose, mouth, and the chin.
Photo Stitching (“Image Registration”) with two techniques: “translation only” and full “homography.”
Rectangle, barcode, and text detection.
Object tracking, for faces or other rectangles in video.
Automatically integrate CoreML models directly into Vision. (Apple showed a demo using an MNIST handwriting recognition model, & Core Image filters to read the number four from a sticky note.)

Three Steps To Vision

Use a VNRequest subclass to ask Vision for something. For example, VNDetectBarcodesRequest for barcodes.
Pass the request to one of two kinds of request handlers, along with a completion block.
In the completion block, we get back the initial request, its results array populated with “observations,” like VNClassificationObservation or VNDetectedObjectObservation.

Request Handlers

Vision offers two request handlers:

Image Request Handlers: For “interactive” exploration of a still image. Image Request Handlers retain images for their lifecyle, as a performance optimization.
Sequence Request Handler: For tracking movement across video. Sequence request handlers don’t have the same optimization. (Imagine how many frames would need to be cached for a 30 second video clip at 24 frames per second - 720.)

Best Practices

Apple discussed three areas for best practices:

1. Image Type

Vision supports a wide variety of image types/sources: CVPixelBuffer, CGImageRef, CIImage, NSURL, and NSData.

Use CVPixelBuffers for streaming. (You get CVPixelBuffers from CMSampleBuffer from a camera stream’s VideoDataOut.) These are a low level format for in-memory RGB data.
Use URL for accessing images that are saved to disk or NSData for images from the web. For URL based images, you don’t need to pass EXIF orientation data. (But you can specify if you want to override the default.)
You can pass in CIImages from Core Image.
Finally, if you already have a UIImage or NSImage, get the CGImageRef and pass that into Vision. Easy.

2. What am I going to do with the image?

Use the appropriate handler. (VNImageRequestHandler or VNSequenceRequestHandler.)
Don’t pre-scale images.
Do pass in EXIF orientation data. (Except for URL based images.)

3. Performance

Dispatch to a background queue, so Vision doesn’t block your UI. In the completion handler, remember to dispatch back to the main queue if you’re updating UI.

Demo

Apple ended the session with a demo.

Apple Car: Getting There With ARKit

2017-06-13T02:00:00-04:00

I watched the intro to ARKit session today and the whole time I’m thinking: That’s great for a car. That’s great for a car. It wasn’t just my gut telling me this. The talking points that Apple brought up are all up to par with the feature set you want out of a car.

Mike Buerli, one of the Apple engineers who ran the ARKit session described the tech as “the illusion that virtual objects are placed in the physical world […] based on what your camera sees.” But why? So you can re-model your home? What about games, you say?

Maybe I’m wrong, but I also bet that ARKit powered games, especially on iPad, won’t be great at long immersive play. Quick encounters in Pokémon Go? Sure. Pokémon Blue in the real world? Nope. I’d get tired holding up an iPad for too long, the same way a touch screen Mac has been maligned in the past. It’s tiresome, and just not a great interface for consumption of large amounts of useful data. I think the key part of that quote is “based on what your camera sees.”

ARKit or CARKit?

If augmented reality is cool for people, it’s downright useful for machines. Let’s pretend we’re writing some autonomous car software.

We probably want to map out the terrain, so we can move the car safely. We’re going to want to make sure other drivers on the road don’t collide with our drivers, and you’re going to want to be able to adapt to new environments based on movement, and light. We’re going to want to be able to respond quickly.

ARKit provides a partial solution for this, with what Apple is calling “World Tracking.” Buerli describes some of this functionality as one of the three components of ARKit:

“With World Tracking we provide you the ability to get your devices relative position in the physical environment,” he said. He also stressed orientation as a huge benefit of using ARKit. ARKit is about where your device, and by extension, you are in the world. Your device can be your phone or your car.

So this is already getting us part of the way there. We can read the terrain with ARKit and we can tell where you are. What about movements and low light?

Having a Vision

The Vision framework isn’t just a fresh take on Apple’s previous software offerings for face detection. Fewer false positives, smaller faces, occlusion detection, and strong profiles (such as the side of a face) were all things Apple tauted in their Vision framework session. (You know that game people play where they pretend the fronts of cars look like faces?)

I imagine each of these features directly correspond to a challenge one could conceivable face while developing autonomous car software. Accuracy is important if you want to detect an approahcing car in the distance, moving at highway speeds.

Apple wouldn’t just re-write something to make it better. There’s usually a deeper, long term motivation involved. Metal enabled a lot of this years technology. This kind of wheel re-inventing means that something is going on, and I think that thing is putting the pieces together for the now confirmed car.

Fewer false positives and smaller faces deal with the vanishing point. Occlusion detection and strong profiles deal with stop signs and intersections. (Cars often approach at 45 degree angles.) These pain points sound exactly like the kinds of problems I’d want to have solved.

Detour(s) Ahead

During the ARKit session, Apple outlined some of the scenarious where ARKit won’t work well, and they all sound like impediments to shipping a safe system: Low light, temporarily blocked cameras, drift. I think that’s where machine learning can help at least little bit.

Low light is a problem around the world. Can Apple make car software work with an alternate band of light, such as infrared? Is a design goal of the project to work with stock hardware that can easily spread adoption across partner manufacturers around the world? That might be a reason not to use another kind of light, and make it work with stock components.

Temporarily blocked cameras are going to be a problem on any camera-based system. It’s the same thing as someone waving something in front of your face or blindfolding you. It happens, and that’s a reason not to rely on cameras 100% for driving. That said, I don’t think this is a problem worth solving.

Lastly, Apple said that objects in an ARKit scene can start to drift of they are moving. That would seemingly pose a problem for detecting other drivers. This is why I think a combination of ARKit and Vision are going to be critical to the success of a car project. ARKit for terrain and world. Vision for tracking nonstationary obstacles.

Thoughts on Hardware

Apple has made some interesting hardware advances recently, and I think that one is notable in particular, given how accurate ARKit is with just a single camera. The dual lens on iPhone 7 Plus isn’t just great for photography, but it also more closely resembles how our brain processes depth. That’s potentially a component of this whole picture as well.

The contrast to the one or two camera system is the panoramic 360 degree cameras we’ve seen on almost every self-driving car prototype to be secretly photographed outside someone’s backyard in Silicon Valley. If Apple has such accurate terrain mapping capable of running in real time on an A9, what are those contraptions on cars doing?

What about CoreML?

I think that machine learning is going to be useful for complementing all of the vision based technology. I wouldn’t rely on machine learning if the cameras go out, but it might be useful for learning traffic patterns or roadwork patterns. There are a number of interesting applications surrounding driving habits as well.

I initially thought that machine learning might be useful for kicking in when a car’s cameras fail. That could be, but even familiarity with the terrain doesn’t guarantee that another crazy driver isn’t passing through on a perpendicular road at 80 miles an hour.

From Here To There: Apple Car

Augmented Reality. Vision. CoreML. Are you getting it yet? These aren’t three devices. It’s one device and we’re calling it Apple Car.

WWDC Wishlist: The Next Apple TV

2017-05-24T12:00:00-04:00

With WWDC just around the corner, here’s my wishlist: “Hey, Siri” for Apple TV, with a smarter Siri.

I think this is all Apple needs to compete with Google Home and Amazon Echo. Everyone else is doing dedicated devices for voice-driven home assistants because they did dongles for television.

Apple TV is unique in that it’s the only one of the three device devices that actually rests on a television stand and stares back at you in all of its beauty. Apple can add a display and a camera to the front and compete with the Amazon Echo Show and Google Home.

A television, a gaming system, and a voice-controlled home assistant. Are you getting it yet?

Swift is not like Kotlin

2017-05-19T11:00:00-04:00

Someone just showed me the “Swift is Like Kotlin” blog post. The page compares Swift and Kotlin code samples side by side, with captions, and I think the post completely missed the point of Swift.

I want to talk about how the stated design goals of each language influence the comparison, and how a syntactical comparison of the two languages is misleading. Then, I’d like to explain why Swift is more like Python than Kotlin. I’ll wrap this up with some (slightly snarky) commentary about iOS vs Android.

Before we begin, I’d like to disclaim that I’ve never looked at Kotlin before today, and it seems like an interesting language. That said, the simple syntactical comparison feels like it’s in really poor taste, so let’s start by comparing Apple and JetBrains’ stated goals and go from there.

Swift.org outlines several goals for Swift as a language. From the Swift homepage:

Swift makes it easy to write software that is incredibly fast and safe by design. […] For students, learning Swift has been a great introduction to modern programming concepts and best practices.

Speed, and safety from errors and crashes. There’s another stated goal that’s also worth highlighting. Swift is about expressiveness, and ease of learning.

In contrast, Kotlin’s website describes has this tag line in big letters:

Statically typed programming language for modern multiplatform applications.

Ok, that’s great. It’s a programming language for modern applications, with data types. The only thing I learn from this blurb is that has a stronger typing system than Python. (This belies the fact that Kotlin is not aimed at ease of learning, or its marketing might have emphasized that a teeny bit more.)

One of the requirements for “a great introdiction” to a language is a syntax that is easy to learn read and write. To say that Kotlin is like Swift is to say that both languages share this attribute.

The code samples demonstrate quite the opposite to me. Everything from keywords to collection declarations are geekier in Kotlin, and often harder to remember for beginners. println is a programmer-speak abbreviation for print line, whereas print is a fully spelled out verb. val is for value and let for, well, let.

As a computer science student and a self-learner, professors’ examples in C, and languages like Ruby with abbreviations galore were frustrating to understand. Swift makes a noticable and successful effort to improve in that area.

Kotlin still doesn’t seem to have array or dictionary/hashmap literal syntax, compared to Swift’s []. Which is easier? Are they “like” each other?

Another comparison is the minimum viable program in each language. Swift’s is one line: print("Hello World!"). Kotlin looks more like this:

package hello

fun main(args: Array<String>) {
    println("Hello world!")
}

I don’t know enough about Kotlin, but if my Java memory serves, interfaces don’t have optional functions. Adopting an interface is all-or-nothing. Swift and Objective-C both allow for protocols to declare their contents as optional for adopters.

As a final example, subclasses in Kotlin are final by default. (I mean this in the informal sense.) You need to mark a class as open for Kotlin to allow subclasses.

Kotlin is very much not like Swift these respects. Python, like Swift, is easy to learn, and might have been a better analogy. To be honest, I’m not sure what the purpose of making this comparison is.

If this post was an the vein of “Android for iOS engineers,” or “Kotlin for Swift developers” it would make more sense to me. “These are things that you’ll be familiar with.” Sure, there are valid comparisons to make between Swift and Kotlin. (For example, I spy templating in the Kotlin code sample.)

It feels like the intention was to stoke fanyboy-ish and fangirl-ish enthusiasm for Kotlin and Android. “Rah rah! Kotlin is as good as Apple’s language.” In fact, someone linked the original article at the top of Kotlin’s Wikipedia page! (Oh, while we’re here, it wasn’t an accident that Google’s Stephanie Saad Cuthberson used Steve Jobs’ famous “one more thing” formula when announcing a “new” language for Android.)

Judging by Kotlin’s first commit in 2010, Kotlin, it’s about the same age as Swift, which also began that year. Two languages, two platforms, two communities. That’s totally ok. We can retain our identities, yet still be friends.

Kotlin is like Java. Swift is like Objective-C. They’re probably both “like” C++.

Swapping App Icons on iOS and tvOS

2017-05-08T12:00:00-04:00

In this post, I’m going to cover the Info.plist changes required to enable your app to locate alternate icons and checking for the availability of alternate icons. I’m also going to provide an Objective-C code sample, and discuss the supportsAlternateIcons API and consider what it might be hinting at. I cover the prompt that users may see when invoking your implementation of this API and how to check if your user is actually using an alternate icon. Finally, we’ll talk about the callback block, and resetting the custom icon back to the original.

I implemented the new icon swapping API available on iOS 10.3, as part of Ultimate Zmanim 11.2’s new Color Themes for premium users. Here’s what I learned:

First, the documentation is a little confusing to read, but if you want to implement this feature, you want to add a dictionary with the CFBundleIcons key to Info.plist. CFBundleIcons has a few sub-keys that you might be familiar with from iOS 6’s Newsstand. (See UINewsstandIcon.) The ones we care about here are CFBundlePrimaryIcon and CFBundleAlternateIcons. Both of these are dictionaries. CFBundlePrimaryIcon contains two keys: A boolean UIPrerenderedIcon and an array with the key CFBundleIconFiles.

To add alternate icons, though, we need to add CFBundleAlternateIcons. The keys in this dictionary are names of icons. Each key contains a dictionary, which matches the contents of the primary icon. That is, each icon key is going to have a UIPrerenderedIcon key and an array of CFBundleIconFiles strings.

Note: On tvOS, there are no prerendered icons, so the CFBundleAlternateIcons key simply contains an array of icon file name strings.

The alternate icon files themselves have to be png files in your app bundle. If you put them into an asset catalog, iOS will not find them. (I tried alternate icon entries, and regular image entries. Neither worked.) Remember to name your icons with the retina display naming convention. For example, if my icon file name is AlternateIconBlue, I want to have a dictionary in CFBundleIcons called CFBundleAlternateIcons. On iOS that’s going to have a key called AlternativeIconBlue with UIPrerenderedIcon (set to YES in my case) and then an array called CFBundleIconFiles containing AlternativeIconBlue again. (On tvOS, it’s a little simpler, as noted above.)

Steve Troughton Smith has a great demo project on Github illustrating how it all works.

Lastly, remember that this API is new to iOS 10.3, and using it without checking for availability is going to crash your app. There’s an API check to use for this, and then there’s a way to check for the API. First, check for the supportsAlternateIcons property on UIApplication, and then use the property itself to ensure that your app supports alternate icons.


  
- (void)setAppIconToUseIconWithFilename:(NSString *)appIconFileName
  if ([[UIApplication sharedApplication] respondsToSelector:NSSelectorFromString(@"supportsAlternateIcons")])
    {
        if (UIApplication.sharedApplication.supportsAlternateIcons)
        {
            [[UIApplication sharedApplication] setAlternateIconName:appIconFileName completionHandler:^(NSError * _Nullable error) {
                if (error) {
                    NSLog(@"Filename: %@, Error swapping icons: %@", appIconFileName, error);
                }
            }];
        }
    }
}

I’m unsure why we need supportsAlternateIcons, since iOS 10.3 and tvOS 10.2 both support alternate icons. App extensions do not support this API, but setAlternateIconName:completionHandler: is already marked as disallowed by the API. We also already have runtime checks to account for the availability of methods and properties. Perhaps this is useful future-proofing if Apple introduces other iOS-based environments that might not support alternate icons. That’s the best explanation I can think of, but if you have an additional perspective, let me know on Twitter.

This code worked for me, and oddly, didn’t prompt me during my testing. Most developers report seeing an alert informing the user that they changed the icon using this API. I don’t know if it’s a development thing, but I’m planning to test this by installing the app over TestFlight and trying it out.

Lots of use cases depend on this alert being suppressed for a seamless experience, but the user-comfort argument is a pretty strong one. If apps change icons and don’t tell the user, that can get pretty annoying pretty fast.

I noticed a few things while looking at UIApplication.h. There’s a property to check if your app is using an alternate icon. You can check by querying UIApplication’s alternateIconName property. If it’s nil, that means your app is using the default icon. That’s a neat trick.

Also, “the completion handler will be invoked asynchronously on an arbitrary background queue; be sure to dispatch back to the main queue before doing any further UI work.” I think this is a fairly common pattern at this point. Most of Apple’s privacy alerts that I’ve seen have similar behavior. It’s a simple thing to account for, but having the documentation confirm is important.

One more thing, if you want to reset your app icon to the default icon, you can pass nil into setAlternateIconName:completionHandler: and UIKit will clear that alternateIconName and reset your app’s icon to its original asset-catelog based icon.

Thanks for reading, and happy coding.

Hello Jekyll!

2017-03-27T22:18:16-04:00

This blows my mind. I was able to deploy an entire brand new blog to my server from my iPhone just by using Prompt and jekyllrb. Unreal!