Reputation: 929
I used to save important App data like login credentials into UserDefaults using the following statement:
UserDefaults.standard.set("[email protected]", forKey: "emailAddress")
Now, I have come to know SwiftUI has introduced new property wrapper called:
@AppStorage
Could anyone please explain how the new feature works?
Upvotes: 41
Views: 21328
Reputation: 1664
I use this extension on Optional
to add support for persisting Optional
s, all Codable
types, Date
s, arrays, dictionaries, etc. with @AppStorage
or @SceneStorage
:
extension Optional: RawRepresentable where Wrapped: Codable {
public var rawValue: String {
guard let data = try? JSONEncoder().encode(self),
let json = String(data: data, encoding: .utf8)
else {
return "{}"
}
return json
}
public init?(rawValue: String) {
guard let data = rawValue.data(using: .utf8),
let value = try? JSONDecoder().decode(Self.self, from: data)
else {
return nil
}
self = value
}
}
Here are some examples in action:
@AppStorage("recentCurrencies") var recentCurrencies: [String]? = nil
@SceneStorage("lastItem") var lastItem: SomeCodableType? = nil
@AppStorage("lastLaunch") var lastLaunch: Date? = nil
These generically persisted properties are optionals, so they need to be unwrapped in your code. For example:
var recentCurrencies = self.recentCurrencies ?? [] // unwrap
if !recentCurrencies.contains(code) {
recentCurrencies.insert(code, at: 0)
}
self.recentCurrencies = Array(recentCurrencies.prefix(3)) // persist!
Upvotes: 0
Reputation: 58113
@AppStorage
property wrapper is a source of truth
that allows you read data from and write it to UserDefaults
. It has a value semantics. You can use @AppStorage
to store any basic data type (like preferences' values or any default values) for as long as the app is installed.
For the best performance, when working with UserDefaults
, you should keep the size of the stored data between 512 KB and 1 MB.
import SwiftUI
struct ContentView: View {
@AppStorage("t_101") var t_101: String = "Terminator T-101"
@AppStorage("t_1000", store: .standard) var t_1000 = "Liquid Metal"
var body: some View {
VStack {
Text("Hey, \(t_101)!").foregroundColor(.indigo)
Text("Hey, \(t_1000)!").foregroundColor(.teal)
Divider()
Button("Real Names") {
t_101 = "Arnie"
t_1000 = "Robbie"
}
}
}
}
Upvotes: 2
Reputation: 1
I have experimented a behavior that I want to share with you. I had a View (called MainView) that used an @AppStorage Bool to display or not a message to users. In this View, I also had many views displaying data loaded from a JSON (cities).
I've developed a 'Add to favorite' feature that uses UserDefault to store a list of cities ID added by user in his/her favorites. The strange behavior was this one: As soon as user added or removed a city as favorite, all MainView's body (and all its child views) was updated. That means all content was reloaded for no reason.
After hours of investigations, specially refactoring all my ObservableObjects (models), my @Published variables and so on, I've find out what was creating this mass update: The @AppStorage in my MainView! As soon as you update any key in 'UserDefaults.standard' (in my case by storing my new favorite), all views's body using an @AppStorage are updated.
So @AppStorage is awesome and easy to use. But be aware of that behavior. You don't expect that a view is updated when you set a key that is not even used in that view!
Upvotes: 0
Reputation: 54516
@AppStorage
is a convenient way to save and read variables from UserDefaults and use them in the same way as @State
properties. It can be seen as a @State
property which is automatically saved to (and read from) UserDefaults
.
You can think of the following:
@AppStorage("emailAddress") var emailAddress: String = "[email protected]"
as an equivalent of this (which is not allowed in SwiftUI and will not compile):
@State var emailAddress: String = "[email protected]" {
get {
UserDefaults.standard.string(forKey: "emailAddress")
}
set {
UserDefaults.standard.set(newValue, forKey: "emailAddress")
}
}
Note that @AppStorage
behaves like a @State
: a change to its value will invalidate and redraw a View.
By default @AppStorage
will use UserDefaults.standard
. However, you can specify your own UserDefaults
store:
@AppStorage("emailAddress", store: UserDefaults(...)) ...
Array
):As mentioned in iOSDevil's answer, AppStorage
is currently of limited use:
types you can use in @AppStorage are (currently) limited to: Bool, Int, Double, String, URL, Data
If you want to use any other type (like Array
), you can add conformance to RawRepresentable
:
extension Array: RawRepresentable where Element: Codable {
public init?(rawValue: String) {
guard let data = rawValue.data(using: .utf8),
let result = try? JSONDecoder().decode([Element].self, from: data)
else {
return nil
}
self = result
}
public var rawValue: String {
guard let data = try? JSONEncoder().encode(self),
let result = String(data: data, encoding: .utf8)
else {
return "[]"
}
return result
}
}
Demo:
struct ContentView: View {
@AppStorage("itemsInt") var itemsInt = [1, 2, 3]
@AppStorage("itemsBool") var itemsBool = [true, false, true]
var body: some View {
VStack {
Text("itemsInt: \(String(describing: itemsInt))")
Text("itemsBool: \(String(describing: itemsBool))")
Button("Add item") {
itemsInt.append(Int.random(in: 1...10))
itemsBool.append(Int.random(in: 1...10).isMultiple(of: 2))
}
}
}
}
Upvotes: 65
Reputation: 11184
We can test this via simple approach:
struct Content: View {
private enum Keys {
static let numberOne = "myKey"
}
@AppStorage(Keys.numberOne) var keyValue2: String = "no value"
var body: some View {
VStack {
Button {
keyValue2 = "Hello"
print(
UserDefaults.standard.value(forKey: Keys.numberOne) as! String
)
} label: {
Text("Update")
}
Text(keyValue2)
}
.padding()
.frame(width: 100)
}
}
Upvotes: 0
Reputation: 119360
In additon to pawello2222 answer, here. is the reimplementation of the AppStorage that I named it as UserDefaultStorage
:
@propertyWrapper
struct UserDefaultStorage<T: Codable> {
private let key: String
private let defaultValue: T
private let userDefaults: UserDefaults
init(key: String, default: T, store: UserDefaults = .standard) {
self.key = key
self.defaultValue = `default`
self.userDefaults = store
}
var wrappedValue: T {
get {
guard let data = userDefaults.data(forKey: key) else {
return defaultValue
}
let value = try? JSONDecoder().decode(T.self, from: data)
return value ?? defaultValue
}
set {
let data = try? JSONEncoder().encode(newValue)
userDefaults.set(data, forKey: key)
}
}
}
This wrapper can store/restore any kind of codable into/from the user defaults. Also, it works in iOS 13 and it doesn't need to import SwiftUI
.
@UserDefaultStorage(key: "myCustomKey", default: 0)
var myValue: Int
Note that it can't be used directly as a State
Upvotes: 9
Reputation: 1816
Disclaimer: iOS 14 Beta 2
In addition to the other useful answers, the types you can use in @AppStorage are (currently) limited to: Bool, Int, Double, String, URL, Data
Attempting to use other types (such as Array) results in the error: "No exact matches in call to initializer"
Upvotes: 9
Reputation: 27363
This is a persistent storage provided by SwiftUI. This code will persist the email across app launches.
struct AppStorageView: View {
@AppStorage("emailAddress") var emailAddress = "[email protected]"
var body: some View {
TextField("Email Address", text: $emailAddress)
}
}
With pure SwiftUI code, we can now persist such data without using UserDefaults
at all.
But if you do want to access the underlying data, it is no secret that the wrapper is using UserDefaults
. For example, you can still update using UserDefaults.standard.set(...)
, and the benefit is that AppStorage observes the store, and the SwiftUI view will update automatically.
Upvotes: 2