Chris' Blog.

My occasional thoughts on iOS development, developers careers, trying to make an income from the App Store, and updates on life in general.

Stack

In practice, I usually find that using a UITableView makes most sense for displaying scrollable content in an app, however every now and again it is handy to use a UIScrollView + UIStackView. The problem is: it occurs infrequently enough that I cannot recall how to set up the constraints! So here’s my notes for my future reference, and hopefully yours too :)

Here’s a screenshot of how to set it up in Xcode: (click to zoom)

Theory

The frame layout guide and content layout guides are only to be used for child views of the scroll, and the child views are to be (usually) only constrained to these guides.
The frame layout guide is for setting child view’s sizes to match the scroll’s visual size.
The content layout guide is what defines the scroll view’s content size.

Vertical scroll setup

Make a UIScrollView and constrain it normally to define its size (eg not using its layout guides).
Put a vertical UIStackView inside the UIScrollView.
Constrain the stack’s leading/trailing/top/bottom to the scroll’s content layout guide.
Make the stack’s width equal to the scroll’s frame layout guide.
Put views in the stack. These views don’t need any constraints put on them at all.

Horizontal scroll setup

Make a UIScrollView and constrain it normally to define its size (eg not using its layout guides).
Put a horizontal UIStackView inside the UIScrollView.
Constrain the stack’s leading/trailing/top/bottom to the scroll’s content layout guide.
Make the stack’s height equal to the scroll’s frame layout guide.
Put views in the stack. These views don’t need any constraints put on them at all.

Paged scroll setup

If you want each child of the stack to be a whole ‘page’:

Horizontal scrolling: Constrain the stack’s childrens’ width to equal the scroll’s frame layout guide.
Vertical scrolling: Constrain the stack’s children’ height to equal the scroll’s frame layout guide.
Set ‘isPagingEnabled’ to true on the scroll.

Thanks for reading, I hope this is helpful, God bless :)

Photo by Fernando Andrade on Unsplash

RSA and EC

I recently had to perform RSA encryption/decryption in Swift for an iOS app. Unfortunately I couldn’t find any examples for how to do this without bringing in a library dependency, which I really wanted to avoid to keep the app efficient and because I can’t reasonably vet their code. And besides: Apple already provides the Security.framework which handles RSA, so it’d be a shame not to use it. It doesn’t bridge nicely to Swift however, so here’s a wrapper I wrote to help use it. I couldn’t find any good examples on the internet so I hope this helps someone:

import Security

// See: https://developer.apple.com/documentation/security/certificate_key_and_trust_services/keys
extension SecKey {
    
    enum KeyType {
        case rsa
        case ellipticCurve
        var secAttrKeyTypeValue: CFString {
            switch self {
            case .rsa:
                return kSecAttrKeyTypeRSA
            case .ellipticCurve:
                return kSecAttrKeyTypeECSECPrimeRandom
            }
        }
    }
    
    /// Creates a random key.
    /// Elliptic curve bits options are: 192, 256, 384, or 521.
    static func createRandomKey(type: KeyType, bits: Int) throws -> SecKey {
        var error: Unmanaged<CFError>?
        let keyO = SecKeyCreateRandomKey([
            kSecAttrKeyType: type.secAttrKeyTypeValue,
            kSecAttrKeySizeInBits: NSNumber(integerLiteral: bits),
        ] as CFDictionary, &error)
        // See here for apple's sample code for memory-managing returned errors
        // from the Security framework:
        // https://developer.apple.com/documentation/security/certificate_key_and_trust_services/keys/storing_keys_as_data
        if let error = error?.takeRetainedValue() { throw error }
        guard let key = keyO else { throw MyErrors.nilKey }
        return key
    }
    
    /// Gets the public key from a key pair.
    func publicKey() throws -> SecKey {
        let publicKeyO = SecKeyCopyPublicKey(self)
        guard let publicKey = publicKeyO else { throw MyErrors.nilPublicKey }
        return publicKey
    }
    
    /// Exports a key.
    /// RSA keys are returned in PKCS #1 / DER / ASN.1 format.
    /// EC keys are returned in ANSI X9.63 format.
    func externalRepresentation() throws -> Data {
        var error: Unmanaged<CFError>?
        let dataO = SecKeyCopyExternalRepresentation(self, &error)
        if let error = error?.takeRetainedValue() { throw error }
        guard let data = dataO else { throw MyErrors.nilExternalRepresentation }
        return data as Data
    }
    
    // Self must be the public key returned by publicKey().
    // Algorithm should be SecKeyAlgorithm.rsaEncryption* or .eciesEncryption*
    func encrypt(algorithm: SecKeyAlgorithm, plaintext: Data) throws -> Data {
        var error: Unmanaged<CFError>?
        let ciphertextO = SecKeyCreateEncryptedData(self, algorithm,
            plaintext as CFData, &error)
        if let error = error?.takeRetainedValue() { throw error }
        guard let ciphertext = ciphertextO else { throw MyErrors.nilCiphertext }
        return ciphertext as Data
    }
    
    // Self must be the private/public key pair returned by createRandomKey().
    // Algorithm should be SecKeyAlgorithm.rsaEncryption* or .eciesEncryption*
    func decrypt(algorithm: SecKeyAlgorithm, ciphertext: Data) throws -> Data {
        var error: Unmanaged<CFError>?
        let plaintextO = SecKeyCreateDecryptedData(self, algorithm,
            ciphertext as CFData, &error)
        if let error = error?.takeRetainedValue() { throw error }
        guard let plaintext = plaintextO else { throw MyErrors.nilPlaintext }
        return plaintext as Data
    }

    enum MyErrors: Error {
        case nilKey
        case nilPublicKey
        case nilExternalRepresentation
        case nilCiphertext
        case nilPlaintext
    }

}

How to use it

It boils down to calling:

createRandomKey(…) to get a key pair.
publicKey() to get just the public key.
externalRepresentation() to get the public key as data that you can send to eg your backend.
encrypt(…) to encrypt something with the public key.
decrypt(…) to decrypt something with the key pair.

Here’s some demo code for using the above:

// Elliptic curve test.
do {
    let keyPair = try SecKey.createRandomKey(
        type: .ellipticCurve,
        bits: 384)
    let publicKey = try keyPair.publicKey()
    let plain = "Chuck Norris has counted to infinity. Twice.".data(using: .utf8)!
    let ciphertext = try publicKey.encrypt(
        algorithm: .eciesEncryptionStandardVariableIVX963SHA256AESGCM,
        plaintext: plain)
    let plainAgain = try keyPair.decrypt(
        algorithm: .eciesEncryptionStandardVariableIVX963SHA256AESGCM,
        ciphertext: ciphertext)
    let string = String(data: plainAgain, encoding: .utf8)! // Don't force-unwrap in real code.
    print("EC decrypted: " + string)
} catch {
    print("Error: \(error)")
}

// RSA test.
do {
    let keyPair = try SecKey.createRandomKey(
        type: .rsa,
        bits: 2048)
    let publicKey = try keyPair.publicKey()
    let plain = "Chuck Norris can set ants on fire with a magnifying glass. At night.".data(using: .utf8)!
    let ciphertext = try publicKey.encrypt(
        algorithm: .rsaEncryptionOAEPSHA1AESGCM,
        plaintext: plain)
    let plainAgain = try keyPair.decrypt(
        algorithm: .rsaEncryptionOAEPSHA1AESGCM,
        ciphertext: ciphertext)
    let string = String(data: plainAgain, encoding: .utf8)! // Don't force-unwrap in real code.
    print("RSA decrypted: " + string)
} catch {
    print("Error: \(error)")
}

Algorithm selection

If you’re integrating with an existing system, you’ll simply have to match their key type and algorithm. But if it’s up to you, here’s some tips for how to choose:

Read Apple’s headers! In Xcode, command-click on SecKeyAlgorithm and read the comments above it. Many algorithms will be noted as legacy, so avoid if possible. And some do not support arbitrary-length data which might be a problem for you. So choose wisely.

And a reasonable option in my opinion is:

Key type: .ellipticCurve
Key size: 384 bits
Algorithm: .eciesEncryptionCofactorVariableIVX963SHA384AESGCM

Note

I’m not a qualified cryptographer, this information carries no warranty, you should talk to a qualified security professional about the implications of when to use this appropriately!

Thanks for reading, I hope this is helpful, God bless :)

Photo by David Clode on Unsplash

Async await

So Async and Await has finally come to Swift, with the release of Xcode 13! Finally! Here’s some examples for practically using it with an existing codebase, interfacing with normal (synchronous) functions.

How can I wrap a callback function with an async one?

Say you have a function with a completion Result<T, Error> callback, you can wrap it to convert it to async/await code using withCheckedThrowingContinuation like so:

// Convert a callback-style function to async await.
func getUser(name: String) async throws -> String {
    try await withCheckedThrowingContinuation {
        continuation in
        getUserViaCallback(name: name, completion: {
            result in
            continuation.resume(with: result)
        })
    }
}

A Result.failure will thus become a thrown error, and a Result.success will be a returned String.

For reference, the function with the completion handler that we’re wrapping above is:

// Completion callback (non async/await) network function.
func getUserViaCallback(name: String, completion:
    @escaping (Result<String, Error>) -> ()) {
        
    enum MyErrors: Error {
        case encoding
        case badUrl
        case noData
        case badData
    }

    guard let safeName = name.addingPercentEncoding(
        withAllowedCharacters: .urlQueryAllowed) else {
        completion(.failure(MyErrors.encoding))
        return
    }
    let urlStr = "https://hacker-news.firebaseio.com/v0/user/\(safeName).json"
    guard let url = URL(string: urlStr) else {
        completion(.failure(MyErrors.badUrl))
        return
    }
    URLSession.shared.dataTask(with: url, completionHandler: {
        data, response, error in
        if let error = error {
            completion(.failure(error))
        }
        guard let data = data else {
            completion(.failure(MyErrors.noData))
            return
        }
        guard let string = String(data: data, encoding: .utf8) else {
            completion(.failure(MyErrors.badData))
            return
        }
        let name = String(string.prefix(20)) // Silly example :)
        completion(.success(name))
    }).resume()
}

How can I orchestrate multiple async calls?

This is where async/await shines: Orchestrating multiple calls. This is a life-saver if you want to make readable code when you have a tricky backend that requires multiple calls to perform one ‘thing’:

// Example of how you can use await to elegantly orchestrate multiple network calls.
func getUsers() async throws -> [String] {
    let a = try await getUser(name: "patio11")
    let b = try await getUser(name: "dang")
    let c = try await getUser(name: "pg")
    let d = try await getUser(name: "llambda")
    return [a, b, c, d]
}

How can I call an async function from a normal (synchronous) one?

Async/await is viral: Any async function must be called by another async one, all the way up the chain. Which obviously isn’t going to be possible with a UIKit app. The ‘trapdoor’ to exit this requirement is the async function. The example below shows how you can use this to convert an async function into one with a familiar Result completion callback. It would be the responsibility of the caller to dispatch to the Main queue to update the UI:

// Call an async function from normal sync code.
// The completion is on an undefined thread/queue.
func getUsersWithCallback(completion: @escaping (Result<[String], Error>) -> ()) {
    async {
        do {
            let users = try await getUsers()
            completion(.success(users))
        } catch {
            completion(.failure(error))
        }
    }
}

What thread does it run on?

Short answer: a GCD Global queue.

Long answer: Apple’s documentation is pretty vague when it comes to which thread your async functions run on. If you’re creating a server app, maybe this isn’t an issue. But if you’re writing a UIKit app, this is very important: You need to be on the main thread to do any UI updates, of course!

When calling an async func from a normal synchronous one, you use this helper:

async(priority: Task.Priority? = nil, operation: () async -> T)

The priorities are basically the same as the GCD ones you’d specify when asking for a global queue:

DispatchQueue.global(qos: DispatchQoS.QoSClass)

Thus I assume async functions simply run on the GCD global queue of whatever priority/QOS you specify (or you can leave it nil to get the default background queue).

What version of iOS does it need?

As of writing (July 2021), your app will require iOS 15 to use async+await. Bummer. However: this is listed as an ‘issue’ in the Xcode beta release notes, which people are taking as a hint that Apple is hard at work resolving this so that your app will not require iOS 15 to use it, thus making it an option for a shipping app. Fingers crossed that once Xcode 13 comes out of beta, async/await will have some form of backwards compatibility.

Thanks for reading, I hope this is helpful, God bless :)

Photo by freezydreamin on Unsplash

You can see older posts in the right panel, under 'archive'.

Chris' Blog.

UIScrollView content and frame layout guides: scroll your UIStackView content purely in storyboards (iOS) 1 May, 2022

Theory

Vertical scroll setup

Horizontal scroll setup

Paged scroll setup

Swift Security framework wrapper for RSA and Elliptic Curve encryption / decryption 21 Sep, 2021

How to use it

Algorithm selection

Note

Simple, practical async await Swift examples 3 Jul, 2021

How can I wrap a callback function with an async one?

How can I orchestrate multiple async calls?

How can I call an async function from a normal (synchronous) one?

What thread does it run on?

What version of iOS does it need?

Archive