Recreating @AppStorage, but for Codable types

Hey, everyone! A few days ago, my buddy, who recently delved into the world of SwiftUI, messaged me: 'Seen @AppStorage? Pretty neat stuff, but it doesn't support Codable types, gotta write some with RawRepresentable.' I was relaxing on the throne when my brain reacted to SwiftUI and pooped an idea: 'Let's create our own implementation but let's jazz it up with Codable and add some UIKit support.' Brilliant plan, right? So, I strolled back to my desk.

No hard feelings, folks! I'm just a dinosaur and a fan of UIKit. So, let's roll!

Intro

What's @AppStorage and how does it work? From ancient times, there's been this thing called NSUserDefaults that can persistently store files. So, @AppStorage is a sleek and reactive wrapper around this well-known API. With a simple code snippet like @AppStorage("key") var property: Int?, instead of the bulky let value = (UserDefaults.standard.value(forKey: "key") as? Int) ?? 0, this propertyWrapper lets you modify UserDefaults by key. But the most convenient part? It instantly captures any changes, triggering a rebuild of our View.

So, to recreate a similar functionality, we'll need knowledge about:

• UserDefaults (NSUserDefaults)
• Combine
• Objective-C (ha-ha, yes)

Writing the propertyWrapper

Let's kick things off with the simplest implementation that fetches and stores values within UserDefaults.

@propertyWrapper
public struct CodableStroage<ValueType> {
    public init(
        _ valueKey: String,
        defaultValue: ValueType,
        userDefaults: UserDefaults = .standard
    ) {
        self.valueKey = valueKey
        self.defaultValue = defaultValue
        self.userDefaults = userDefaults
    }

    public var defaultValue: ValueType
    public var valueKey: String
    public var userDefaults: UserDefaults

    public var wrappedValue: ValueType {
        get { userDefaults.value(forKey: valueKey) as? ValueType ?? defaultValue }
        set { userDefaults.set(newValue, forKey: valueKey) }
    }
}

Now, to ensure our SwiftUI View can receive updates and rebuild, let's leverage the DynamicProperty protocol and complete its implementation for our propertyWrapper. According to the documentation, the update() method in this protocol has a default implementation, so we won't have to write a lot.

extension CodableStorage: DynamicProperty {}

Next, let's make some updates to the CodableStorage implementation to get that SwiftUI magic going. To achieve this, we'll use the standard @ObservedObject and ObservableObject.

First of all, we need to create a class responsible for data storage to ensure immutability in our structure. And since we want to support Codable types for storage, let's immediately incorporate JSONEncoder & JSONDecoder. Also, let's add an Equatable constraint to our ValueType to avoid unnecessarily triggering view hierarchy updates in the future.

internal final class SubscriptionStorage<ValueType>: ObservableObject
    where
    ValueType: Codable,
    ValueType: Equatable
{
    internal init(
        encoder: JSONEncoder,
        decoder: JSONDecoder,
        valueKey: String,
        defaultValue: ValueType,
        userDefaults: UserDefaults
    ) {
        self.userDefaults = userDefaults
        self.valueKey = valueKey

        self.defaultValue = defaultValue

        // 1. Retrieving the initial value from UserDefaults
        if let data = userDefaults.data(forKey: valueKey),
           let decodedValue = try? decoder.decode(ValueType.self, from: data)
        {
            self.currentValue = decodedValue
        } else {
            self.currentValue = nil
        }

        self.encoder = encoder
        self.decoder = decoder
    }
}

Add an update function to this class where the main magic will happen with ObservableObject.

internal func update(_ currentValue: ValueType) {
    guard let encodedValue = try? encoder.encode(currentValue)
    else {
        return
    }

    // 1. Checking if the value is different from the previous one
    if value != encodedValue {
        // 2. Notifying all observers about pending changes
        objectWillChange.send()
    }

    // 3. Updating the value in persistent storage
    userDefaults.setValue(encodedValue, forKey: valueKey)

    // 4. Updating our in-memory storage
    self.currentValue = currentValue
}

Now, let's update our main propertyWrapper and make use of the SubscriptionStorage we just created.

@propertyWrapper
public struct CodableStroage<ValueType>
    where
    // 1. Adding constraints on types to allow our SubscriptionStorage to work with them
    ValueType: Codable,
    ValueType: Equatable
{
    // Including necessary parameters in .init
    public init(
        _ valueKey: String,
        defaultValue: ValueType,
        userDefaults: UserDefaults? = nil,
        decoder: JSONDecoder? = nil,
        encoder: JSONEncoder? = nil
    ) {
        self.init(
            valueKey,
            defaultValue: defaultValue,
            userDefaults: userDefaults ?? .standart,
            decoder: decoder ?? JSONDecoder(),
            encoder: encoder ?? JSONEncoder()
        )
    }

    public var wrappedValue: ValueType {
        get { storage.value }
        // 2. Highlighting that our structure is now immutable even when values change
        nonmutating set { storage.update(newValue) }
    }

    public var defaultValue: ValueType { storage.defaultValue }
    public var valueKey: String { storage.valueKey }

    // 3. Attaching `@ObservedObject` to our `ObservableObject`
    @ObservedObject
    private var storage: SubscriptionStorage<ValueType>
}

Also, we can add sugar to the CodableStorage initializer to simplify the code for optional data types.

public init(
    _ valueKey: String,
    defaultValue: ValueType = nil,
    userDefaults: UserDefaults? = nil,
    decoder: JSONDecoder? = nil,
    encoder: JSONEncoder? = nil
) where ValueType: ExpressibleByNilLiteral {
    self.init(
        valueKey,
        defaultValue: defaultValue,
        userDefaults: userDefaults ?? .standard,
        decoder: decoder ?? JSONDecoder(),
        encoder: encoder ?? JSONEncoder()
    )
}

Now, there's no need to write @CodableStorage("key", defaultValue: nil) each time; instead, we can simply use @CodableStorage("key").

First run

Our code is functioning, but as seen in the video, it's not quite as expected. The issue lies in the fact that two different CodableStorage instances have separate stores and aren't synchronized at all. Let's fix that!

Synchronization

To synchronize different instances of our CodableStorage, let's utilize the good old NSUserDefaultsDidChangeNotification API. We'll write our own Publisher and Subscription, which will respond to changes from UserDefaults and send this information to their subscribers.

The Subscription object

internal final class UserDefaultsSubscription<ValueType, SubscriberType>:
    Subscription
    where
    ValueType: Equatable,
    SubscriberType: Subscriber,
    SubscriberType.Input == ValueType,
    SubscriberType.Failure == Never
{
    internal func request(_ demand: Subscribers.Demand) {
        guard demand > 0
        else {
            return
        }

        // 1. Immediately send new data to the subscriber
        userDefaultsDidChange(userDefaults)

        // 2. Subscribe to updates from all UserDefaults and wait for changes
        subscription = NotificationCenter.default.addObserver(
            forName: UserDefaults.didChangeNotification,
            object: nil,
            queue: OperationQueue(),
            using: { [weak self] notification in
                guard let userDefaults = notification.object as? UserDefaults
                else {
                    return
                }

                // 3. Process updates
                self?.userDefaultsDidChange(userDefaults)
            }
        )
    }

    private func userDefaultsDidChange(_ userDefaults: UserDefaults) {
        // 4. Verify that the subscription exists and UserDefaults matches the one we created with
        guard let subscriber, self.userDefaults == userDefaults
        else {
            return
        }

        let updatedValue = userDefaults.object(forKey: valueKey)

        // 5. Check if the value has changed
        guard let updatedValue = updatedValue as? ValueType, currentValue != updatedValue
        else {
            return
        }

        currentValue = updatedValue

        // 6. Send
        let _ = subscriber.receive(updatedValue)
    }
}

The Publisher object

internal final class UserDefaultsPublisher<ValueType>:
    Publisher
    where
    ValueType: Equatable
{
    internal typealias Output = ValueType
    internal typealias Failure = Never

    internal func receive<S>(
        subscriber: S
    ) where S: Subscriber, S.Failure == Failure, S.Input == Output {
        subscriber.receive(subscription: UserDefaultsSubscription(
            subscriber: subscriber,
            userDefaults: userDefaults,
            valueKey: valueKey,
            currentValue: initialValue
        ))
    }
}

Now, we'll need to update the SubscriptionStorage to retrieve data directly from UserDefaults using Combine and UserDefaultsPublisher.

internal final class SubscriptionStorage<ValueType>: ObservableObject
    where
    ValueType: Codable,
    ValueType: Equatable
{
    private var cancellables: Set<AnyCancellable> = .init()

    internal init(/* ... */) {
        // 1. Create UserDefaultsPublisher and subscribe to changes in our UserDefaults
        let publisher = UserDefaultsPublisher(
            initialValue: try? encoder.encode(defaultValue),
            userDefaults: userDefaults,
            valueKey: valueKey.rawValue
        ).eraseToAnyPublisher()

        publisher
            .receive(on: DispatchQueue.main) // We can only dispatch updates to the view hierarchy from the main thread
            .sink(receiveValue: { [weak self] value in
                self?.receive(value)
            })
            .store(in: &cancellables)
    }

    internal func update(_ currentValue: ValueType) {
        guard let encodedValue = try? encoder.encode(currentValue)
        else {
            return
        }

        // 3. Now, as we'll directly receive any changes from UserDefaults, here we just need to update the value on disk
        userDefaults.setValue(encodedValue, forKey: valueKey)
    }

    private func receive(_ data: Data) {
        guard let decodedValue = try? decoder.decode(ValueType.self, from: data)
        else {
            return
        }
        // 4. Verify that the value is updated and dispatch it to our subscribers
        if value != decodedValue {
            objectWillChange.send()
        }
        currentValue = decodedValue
    }
}

Voilà, you're amazing! Let's conduct the next experiment and try running our code again.

And it's not working again. How come? Where did we make a mistake? Well, time to debug. And for that, we'll cover ourselves with print() all over the program, haha.

Fortunately, debugging didn't take long, and the problem was quickly localized — it within UserDefaultsSubscription. Who can guess where the trouble lies? Hint:

private func userDefaultsDidChange(_ userDefaults: UserDefaults) {
    guard let subscriber, self.userDefaults == userDefaults
    else {
        return
    }
    // ...
}

Correct, you can't simply compare UserDefaults like that. Even instances with the same suiteName are not equal! So, it seems we need to figure out a way to identify UserDefaults differently. Let's utilize Hopper Disassembler for this purpose.

If we were using the UserDefaults object passed in our initializer as the argument (as object: parameter) in the NotificationCenter.subscribe() method, we wouldn't receive any notifications at all. :(

Here we discover that NSUserDefaults actually has a certain _identifier_. Well, let's try to retrieve it and make use of it. Remember when I mentioned Objective-C earlier? Well, the time has come. Now we'll be fetching the value of private properties, and for this, we'll need some runtime magic. Let's write a small extension for UserDefaults!

import ObjectiveC

internal extension UserDefaults {
    var identifier: String {
        guard let ivar = class_getInstanceVariable(UserDefaults.self, "_identifier_"),
              let value = object_getIvar(self, ivar) as? NSString
        else {
            #if DEBUG
            fatalError("UserDefaults API has been changed")
            #else
            return UUID().uuidString
            #endif
        }

        return value as String
    }
}

Using the class_getInstanceVariable function, we retrieve a reference to the ivar, then extract its value with object_getIvar. Just to be safe, we'll make the app crash (only in DEBUG mode) if the API has changed (although that's highly unlikely). Now, let's modify the code a bit and try running it again.

private func userDefaultsDidChange(_ userDefaults: UserDefaults) {
    guard let subscriber, self.userDefaults.identifier == userDefaults.identifier
    else {
        return
    }
    // ...
}

Excuse me, sir! Do we love UIKit?

There won't be any rocket science here, just adding one method to SubscriptionStorage and CodableStorage.

extension SubscriptionStorage {
    internal func eraseToAnyPublisher() -> AnyPublisher<ValueType, Never> {
        let decoder = decoder
        let publisher = UserDefaultsPublisher(
            initialValue: encoder._encode(defaultValue),
            userDefaults: userDefaults,
            valueKey: valueKey.rawValue
        )

        return publisher.compactMap({ data in
            decoder._decode(T.self, from: data)
        }).eraseToAnyPublisher()
    }
}

extension CodableStroage {
    public var projectedValue: CodableStroage<ValueType> { self }

    func eraseToAnyPublisher() -> AnyPublisher<ValueType, Never> {
        storage.eraseToAnyPublisher()
    }
}

Here, we've added projectedValue, which allows us to access the propertyWrapper by using $ before the wrapped variable's name instead. Now, if we're writing code with UIKit, we can do something like this:

class Subview: UIView {
    init() {
        super.init(frame: .zero)
        $value.eraseToAnyPublisher().sink(receiveValue: { value in
            print(value)
        }).store(in: &cancellables)
    }

    @CodableStroage("key", defaultValue: 0)
    private var value: Int

    private var cancellables: Set<AnyCancellable> = .init()
}

It seems there might be a small bug

Because CodableStorage can accept Optional as generic ValueType, there's an issue when we save our data to disk. We pass our value to JSONEncoder, and it wraps nil, turning it into null. Therefore, there might be a small problem during the decoding stage. Let's fix that! To determine that the value received at runtime as ValueType is actually nil. But we can't simply add a check like value == nil because the compiler will complain at us, ha-ha.

// 1. Let's write our protocol called `AnyOptional`, which will allow us to determine at runtime whether it's nil or not.
private protocol AnyOptional {
    var isEmpty: Bool { get }
}

// 2. We'll make sure all Optionals are now of type `AnyOptional`.
extension Optional: AnyOptional {
    var isEmpty: Bool { self == nil }
}

// 3. We'll write a simple function.
internal func isnil(_ instance: Any) -> Bool {
    guard let _optional = instance as? AnyOptional
    else {
        return false
    }
    return _optional.isEmpty
}

And now, once again (for the last time, I promise!), let's update our SubscriptionStorage.

internal func update(_ currentValue: ValueType) {
    guard !isnil(currentValue)
    else {
        userDefaults.removeObject(forKey: valueKey)
        return
    }

    guard let encodedValue = try? encoder.encode(currentValue)
    else {
        return
    }

    userDefaults.setValue(encodedValue, forKey: valueKey)
}

It looks like we're all set! Now you can use CodableStorage to store Codable types inside UserDefaults.

Thanks for sticking around until the end! You can check out the code for the finished library here - 0xstragner/CodableStorage.

Comments

[Michał Kowalski]

Seems very convenient to use but I prefer to store Codable objects directly in file on disk.