UserDefaults – Augmented Code

Loading URL previews using LinkPresentation framework in Swift

iOS and macOS got a new framework in WWDC’19 named LinkPresentation. LinkPresentation enables fetching URL previews.

Adding LPLinkView for presenting preview

LPLinkView is a view subclass meant for rendering LPLinkMetadata. LPLinkMetadata contains information about the link: title, icon, image, video.

	import LinkPresentation

	let linkView = LPLinkView(metadata: LPLinkMetadata())
	linkView.translatesAutoresizingMaskIntoConstraints = false
	stackView.insertArrangedSubview(linkView, at: 0)

view raw ViewController.swift hosted with ❤ by GitHub

Adding LPLinkView to stack view

Fetching previews with LPMetadataProvider

Instances of LPLinkMetadata are fetched using LPLinkMetadataProvider for a given url. LPLinkMetadata is conforming to NSSecureCoding what enables a way of converting it to Data and storing the metadata on disk. Next time we need metadata for this url, we can use a locally cached data instead. Archiving and unarchiving is done with help of NSKeyedArchiver and NSKeyedUnarchiver and in the example archived data is stored in UserDefaults. In real apps it makes sense to store the data in separate files instead and not polluting UserDefaults with preview data.

	private let metadataStorage = MetadataStorage()
	private lazy var metadataProvider = LPMetadataProvider()
	private weak var linkView: LPLinkView?

	@IBAction func loadPreview(_ sender: UIButton) {
	if let text = textField.text, let url = URL(string: text) {
	// Avoid fetching LPLinkMetadata every time and archieve it disk
	if let metadata = metadataStorage.metadata(for: url) {
	linkView?.metadata = metadata
	return
	}
	metadataProvider.startFetchingMetadata(for: url) { [weak self] (metadata, error) in
	if let error = error {
	print(error)
	}
	else if let metadata = metadata {
	DispatchQueue.main.async { [weak self] in
	self?.metadataStorage.store(metadata)
	self?.linkView?.metadata = metadata
	}
	}
	}
	}
	}

view raw ViewController.swift hosted with ❤ by GitHub

Fetching and caching LPMetadata

	struct MetadataStorage {
	private let storage = UserDefaults.standard

	func store(_ metadata: LPLinkMetadata) {
	do {
	let data = try NSKeyedArchiver.archivedData(withRootObject: metadata, requiringSecureCoding: true)
	var metadatas = storage.dictionary(forKey: "Metadata") as? [String: Data] ?? [String: Data]()
	while metadatas.count > 10 {
	metadatas.removeValue(forKey: metadatas.randomElement()!.key)
	}
	metadatas[metadata.originalURL!.absoluteString] = data
	storage.set(metadatas, forKey: "Metadata")
	}
	catch {
	print("Failed storing metadata with error \(error as NSError)")
	}
	}

	func metadata(for url: URL) -> LPLinkMetadata? {
	guard let metadatas = storage.dictionary(forKey: "Metadata") as? [String: Data] else { return nil }
	guard let data = metadatas[url.absoluteString] else { return nil }
	do {
	return try NSKeyedUnarchiver.unarchivedObject(ofClass: LPLinkMetadata.self, from: data)
	}
	catch {
	print("Failed to unarchive metadata with error \(error as NSError)")
	return nil
	}
	}
	}

view raw MetadataStore.swift hosted with ❤ by GitHub

Local LPMetadata storage using UserDefaults as storage

Summary

LinkPresentation framework adds a easy way of fetching previews for web pages. It provides a LPLinkView class making it extremely easy to render the preview.

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.

Example Project

LinkPresentationView (Xcode 11 GM)

Storing struct in UserDefaults

Structs can’t be directly stored in UserDefaults because UserDefaults does not know how to serialize it. As UserDefaults is backed by plist files, struct needs to be converted representation supported by it. The core idea boils down to the question, how to convert struct into Dictionary.

Converting struct to Dictionary

The most straight-forward way would be to manually create dictionary by adding all the properties one by one. Depending on the struct, it might get pretty long and also requires maintenance when changing the struct. Therefore, let’s take a look on a way of converting struct into JSON representation instead. This can be achieved by conforming to Encodable and using JSONEncoder and JSONSerialization. In the same way, we can convert Dictionary back to struct with JSONSerialization, JSONDecoder and conforming to Decodable. When conforming struct to Encodable and Decodable, Swift compiler will take care of generating default implementations for methods in those protocols. JSONEncoder and JSONDecoder use those methods for converting struct to Data and back. It should be noted that we could just store data in user defaults. But as data is not human-readable, let’s convert it to Dictionary instead.

	struct Context: Codable {
	let duration: TimeInterval
	let view: String
	}

	struct SearchInfo: Codable {
	let query: String
	let numberOfMatches: Int
	let context: Context
	}

	let searchInfos = [SearchInfo(query: "query1", numberOfMatches: 1, context: Context(duration: 1.0, view: "view1")),
	SearchInfo(query: "query2", numberOfMatches: 2, context: Context(duration: 2.0, view: "view2"))]

	// Converting to dictionary
	extension SearchInfo {
	var dictionaryRepresentation: [String: Any] {
	let data = try! JSONEncoder().encode(self)
	return try! JSONSerialization.jsonObject(with: data, options: []) as! [String : Any]
	}
	}

	// Converting back to struct
	extension SearchInfo {
	init?(dictionary: [String: Any]) {
	guard let data = try? JSONSerialization.data(withJSONObject: dictionary, options: []) else { return nil }
	guard let info = try? JSONDecoder().decode(SearchInfo.self, from: data) else { return nil }
	self = info
	}
	}

	let defaults = UserDefaults()

	// [Struct] -> [Dictionary]
	let searchInfoDictionaries = searchInfos.map({ $0.dictionaryRepresentation })

	// [Dictionary] to UserDefaults
	defaults.set(searchInfoDictionaries, forKey: "Searches")

	// [Dictionary] from UserDefaults
	let dictionariesFromUserDefaults = defaults.array(forKey: "Searches")! as! [[String: Any]]

	// [Dictionary] -> [Struct]
	let convertedSearchInfos = dictionariesFromUserDefaults.compactMap({ SearchInfo(dictionary: $0) })

view raw StructToDictionary.swift hosted with ❤ by GitHub

Adding DictionaryConvertible and DictionaryDecodable

This implementation can be made a bit more usable by using protocols and protocol extensions for providing default implementations. This makes it extremely easy to adopt this to any objects.

	protocol DictionaryConvertible {
	var dictionaryRepresentation: [String: Any] { get }
	}

	protocol DictionaryDecodable {
	init?(dictionary: [String: Any])
	}

	typealias DictionaryRepresentable = DictionaryConvertible & DictionaryDecodable

	extension DictionaryConvertible where Self: Encodable {
	var dictionaryRepresentation: [String: Any] {
	let data = try! JSONEncoder().encode(self)
	return try! JSONSerialization.jsonObject(with: data, options: []) as! [String : Any]
	}
	}

	extension DictionaryDecodable where Self: Decodable {
	init?(dictionary: [String: Any]) {
	guard let data = try? JSONSerialization.data(withJSONObject: dictionary, options: []) else { return nil }
	guard let info = try? JSONDecoder().decode(Self.self, from: data) else { return nil }
	self = info
	}
	}

	struct AutocompleteResult: Codable, DictionaryRepresentable {
	let text: String
	let suggestions: [String]
	}

view raw DictionaryRepresentable.swift hosted with ❤ by GitHub

Summary

Using Swift’s Codable together with JSONEncoder, JSONDecoder and JSONSerialization we can skip writing code for converting data into different types and instead, providing a concise implementation for turning structs into dictionaries. We only talked about structs but this approach can be applied to classes as well.

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.

Playground

StoringStructInUserDefaults (Xcode 10.2.1, Swift 5.0)