Realm Database with SwiftUI QuickStart
On this page
Prerequisites
- Have Xcode 12.4 or later (minimum Swift version 5.3.1).
- Create a new Xcode project using the SwiftUI "App" template with a minimum iOS target of 15.0.
- Install the Swift SDK. This SwiftUI app requires a minimum SDK version of 10.19.0.
Overview
This page provides a small working app to get you up and running with Realm and SwiftUI quickly. If you'd like to see additional examples, including more explanation about Realm's SwiftUI features, see: Use Realm Database with SwiftUI.
This page contains all of the code for a working Realm and SwiftUI app. The app starts on the ItemsView, where you can edit a list of items:
- Press the Add button on the bottom right of the screen to add randomly-generated items.
- Press the Edit button on the top right to modify the list order, which the app persists in the realm.
- You can also swipe to delete items.
When you have items in the list, you can press one of the items to navigate to the ItemDetailsView. This is where you can modify the item name or mark it as a favorite:
- Press the text field in the center of the screen and type a new name. When you press Return, the item name should update across the app.
- You can also toggle its favorite status by pressing the heart toggle in the top right.
This guide optionally integrates with Realm Sync. See Integrate MongoDB Realm and Sync below.
Get Started
We assume you have created an Xcode project with the SwiftUI "App"
template. Open the main Swift file and delete all of the code inside,
including any @main
App
classes that Xcode generated for you. At
the top of the file, import the Realm and SwiftUI frameworks:
import RealmSwift import SwiftUI
Just want to dive right in with the complete code? Jump to Complete Code below.
Define Models
A common Realm data modeling use case is to have "things" and "containers of things". This app defines two related Realm object models: item and group.
An item has two user-facing properties:
- A randomly generated-name, which the user can edit.
- An
isFavorite
boolean property, which shows whether the user "favorited" the item.
A group contains items. You can extend the group to have a name and an association with a specific user, but that's out of scope of this guide.
Paste the following code into your main Swift file to define the models:
/// Random adjectives for more interesting demo item names let randomAdjectives = [ "fluffy", "classy", "bumpy", "bizarre", "wiggly", "quick", "sudden", "acoustic", "smiling", "dispensable", "foreign", "shaky", "purple", "keen", "aberrant", "disastrous", "vague", "squealing", "ad hoc", "sweet" ] /// Random noun for more interesting demo item names let randomNouns = [ "floor", "monitor", "hair tie", "puddle", "hair brush", "bread", "cinder block", "glass", "ring", "twister", "coasters", "fridge", "toe ring", "bracelet", "cabinet", "nail file", "plate", "lace", "cork", "mouse pad" ] /// An individual item. Part of a `Group`. final class Item: Object, ObjectKeyIdentifiable { /// The unique ID of the Item. `primaryKey: true` declares the /// _id member as the primary key to the realm. true) var _id: ObjectId (primaryKey: /// The name of the Item, By default, a random name is generated. var name = "\(randomAdjectives.randomElement()!) \(randomNouns.randomElement()!)" /// A flag indicating whether the user "favorited" the item. var isFavorite = false /// The backlink to the `Group` this item is a part of. "items") var group: LinkingObjects<Group> (originProperty: } /// Represents a collection of items. final class Group: Object, ObjectKeyIdentifiable { /// The unique ID of the Group. `primaryKey: true` declares the /// _id member as the primary key to the realm. true) var _id: ObjectId (primaryKey: /// The collection of Items in this group. var items = RealmSwift.List<Item>() }
Views and Observed Objects
The entrypoint of the app is the ContentView class that derives from
SwiftUI.App
. For now, this always displays the
LocalOnlyContentView. Later, this will show the SyncContentView
when Realm Sync is enabled.
/// The main screen that determines whether to present the SyncContentView or the LocalOnlyContentView. /// For now, it always displays the LocalOnlyContentView. @main struct ContentView: SwiftUI.App { var body: some Scene { WindowGroup { LocalOnlyContentView() } } }
You can use a realm other than the default realm by passing an environment object from higher in the View hierarchy:
LocalOnlyContentView() .environment(\.realmConfiguration, Realm.Configuration( /* ... */ ))
The LocalOnlyContentView has an @ObservedResults groups. This implicitly uses the default realm to load all groups when the view appears.
This app only expects there to ever be one group. If there is a group in the realm, the LocalOnlyContentView renders an ItemsView for that group.
If there is no group already in the realm, then the
LocalOnlyContentView displays a ProgressView while it adds one. Because
the view observes the groups thanks to the @ObservedResults
property
wrapper, the view immediately refreshes upon adding that first group and
displays the ItemsView.
/// The main content view if not using Sync. struct LocalOnlyContentView: View { // Implicitly use the default realm's objects(Group.self) Group.self) var groups ( var body: some View { if let group = groups.first { // Pass the Group objects to a view further // down the hierarchy ItemsView(group: group) } else { // For this small app, we only want one group in the realm. // You can expand this app to support multiple groups. // For now, if there is no group, add one here. ProgressView().onAppear { $groups.append(Group()) } } } }
Starting in SDK version 10.12.0, you can use an optional key path parameter
with @ObservedResults
to filter change notifications to only those
occurring on the provided key path or key paths. For example:
@ObservedResults(MyObject.self, keyPaths: ["myList.property"])
The ItemsView receives the group from the parent view and stores it in an @ObservedRealmObject property. This allows the ItemsView to "know" when the object has changed regardless of where that change happened.
The ItemsView iterates over the group's items and passes each item to an ItemRow for rendering as a list.
To define what happens when a user deletes or moves a row, we pass the
remove
and move
methods of the Realm
List as the handlers of the respective
remove and move events of the SwiftUI List. Thanks to the
@ObservedRealmObject
property wrapper, we can use these methods
without explicitly opening a write transaction. The property wrapper
automatically opens a write transaction as needed.
/// The screen containing a list of items in a group. Implements functionality for adding, rearranging, /// and deleting items in the group. struct ItemsView: View { /// The group is a container for a list of items. Using a group instead of all items /// directly allows us to maintain a list order that can be updated in the UI. var group: Group /// The button to be displayed on the top left. var leadingBarButton: AnyView? var body: some View { NavigationView { VStack { // The list shows the items in the realm. List { ForEach(group.items) { item in ItemRow(item: item) }.onDelete(perform: $group.items.remove) .onMove(perform: $group.items.move) }.listStyle(GroupedListStyle()) .navigationBarTitle("Items", displayMode: .large) .navigationBarBackButtonHidden(true) .navigationBarItems( leading: self.leadingBarButton, // Edit button on the right to enable rearranging items trailing: EditButton()) // Action bar at bottom contains Add button. HStack { Spacer() Button(action: { // The bound collection automatically // handles write transactions, so we can // append directly to it. $group.items.append(Item()) }) { Image(systemName: "plus") } }.padding() } } } }
Finally, the ItemRow and ItemDetailsView classes use the
@ObservedRealmObject
property wrapper with the item passed in from
above. These classes demonstrate a few more examples of how to use the
property wrapper to display and update properties.
/// Represents an Item in a list. struct ItemRow: View { var item: Item var body: some View { // You can click an item in the list to navigate to an edit details screen. NavigationLink(destination: ItemDetailsView(item: item)) { Text(item.name) if item.isFavorite { // If the user "favorited" the item, display a heart icon Image(systemName: "heart.fill") } } } } /// Represents a screen where you can edit the item's name. struct ItemDetailsView: View { var item: Item var body: some View { VStack(alignment: .leading) { Text("Enter a new name:") // Accept a new name TextField("New name", text: $item.name) .navigationBarTitle(item.name) .navigationBarItems(trailing: Toggle(isOn: $item.isFavorite) { Image(systemName: item.isFavorite ? "heart.fill" : "heart") }) }.padding() } }
@ObservedRealmObject
is a frozen object. If you want to modify
the properties of an @ObservedRealmObject
directly in a write transaction, you must .thaw()
it first.
At this point, you have everything you need to work with Realm Database and SwiftUI. Test it out and see if everything is working as expected. Read on to learn how to integrate this app with Realm Sync.
Integrate MongoDB Realm and Sync
Now that we have a working Realm Database app, we can optionally integrate with Realm Sync. Sync allows you to you see the changes you make across devices. Before you can add sync to this app, make sure to:
- Create a Realm app.
- Enable anonymous authentication.
- Use Partition-Based Sync
- Specify a cluster and database.
- Turn on Development Mode.
- Use
_partition
as a partition key. - For Permissions, select the template: User can only read and write their own data.
- Enable Sync, and deploy your application updates.
The Sync version of this app changes the app flow a bit. The first screen becomes the LoginView. When you press the Log in button, the app navigates to the ItemsView, where you see the synced list of items in a single group.
At the top of the source file, initialize an optional Realm app with your Realm app ID:
// MARK: MongoDB Realm (Optional) // The Realm app. Change YOUR_REALM_APP_ID_HERE to your Realm app ID. // If you don't have a Realm app and don't wish to use Sync for now, // you can change this to: // let app: RealmSwift.App? = nil let app: RealmSwift.App? = RealmSwift.App(id: YOUR_REALM_APP_ID_HERE)
You can change the app reference to nil
to switch back to
local-only (non-Realm Sync) mode.
Let's update the main ContentView to show the SyncContentView if the
app reference is not nil
:
/// The main screen that determines whether to present the SyncContentView or the LocalOnlyContentView. @main struct ContentView: SwiftUI.App { var body: some Scene { WindowGroup { // Using Sync? if let app = app { SyncContentView(app: app) } else { LocalOnlyContentView() } } } }
We define the SyncContentView below.
The SyncContentView observes the Realm app instance. The app instance is the interface to the MongoDB Realm backend, which provides the user authentication required for Sync. By observing the app instance, the SyncContentView can react when a user logs in or out.
This view has two possible states:
- If the Realm app does not have a currently logged-in user, show the LoginView.
- If the Realm app does have a logged-in user, show the OpenSyncedRealmView.
Here's the code for the SyncContentView:
/// This view observes the Realm app object. /// Either direct the user to login, or open a realm /// with a logged-in user. struct SyncContentView: View { // Observe the Realm app object in order to react to login state changes. var app: RealmSwift.App var body: some View { if let user = app.currentUser { // If there is a logged in user, pass the user ID as the // partitionValue to the view that opens a realm. OpenSyncedRealmView().environment(\.partitionValue, user.id) } else { // If there is no user logged in, show the login view. LoginView() } } }
From here, we pass the logged in user's ID to the OpenSyncedRealmView as a
partitionValue
using an environment object. This is the view responsible
for opening a realm and working with the data. With Sync, we can only
open the realm once a user is logged in.
OpenSyncedRealmView().environment(\.partitionValue, user.id)
Once logged in, we open the realm asynchronously with the AsyncOpen property wrapper. In this example, we leave the
partitionValue
an empty string since we are getting that value from
the environment object passed in from above.
YOUR_REALM_APP_ID_HERE, partitionValue: "", timeout: 4000) var asyncOpen (appId:
The OpenSyncedRealmView switches on the AsyncOpenState
enum, which lets us show different views
based on the state. In our example, we show a ProgressView
while we're
connecting to the Realm app and the realm is syncing. We then open the
realm, passing the group
to the ItemsView
, or show an ErrorView
if we can't open the realm.
When opening a synced realm, use the AsyncOpen property wrapper to always download synced changes
before opening the realm, or the AutoOpen property wrapper to open a realm while syncing
in the background. AsyncOpen
requires the user to be online,
while AutoOpen
opens a realm even if the user is offline.
This view has a few different states:
- While connecting or waiting for login, show a
ProgressView
. - While downloading changes to the realm, show a
ProgressView
with a progress indicator. - When the realm opens, check for a group object. If one does not exist yet, create one. Then, show the ItemsView for the group in the realm. Provide a LogoutButton that the ItemsView can display on the top left of the navigation bar.
- If there is an error loading the realm, show an error view containing the error.
Here's the code for the OpenSyncedRealmView:
/// This view opens a synced realm. struct OpenSyncedRealmView: View { // Use AsyncOpen to download the latest changes from // your Realm app before opening the realm. // Leave the `partitionValue` an empty string to get this // value from the environment object passed in above. YOUR_REALM_APP_ID_HERE, partitionValue: "", timeout: 4000) var asyncOpen (appId: var body: some View { switch asyncOpen { // Starting the Realm.asyncOpen process. // Show a progress view. case .connecting: ProgressView() // Waiting for a user to be logged in before executing // Realm.asyncOpen. case .waitingForUser: ProgressView("Waiting for user to log in...") // The realm has been opened and is ready for use. // Show the content view. case .open(let realm): ItemsView(group: { if realm.objects(Group.self).count == 0 { try! realm.write { realm.add(Group()) } } return realm.objects(Group.self).first! }(), leadingBarButton: AnyView(LogoutButton())).environment(\.realm, realm) // The realm is currently being downloaded from the server. // Show a progress view. case .progress(let progress): ProgressView(progress) // Opening the Realm failed. // Show an error view. case .error(let error): ErrorView(error: error) } } }
When you run the app and see the main UI, there are no items in the view.
That's because we're using anonymous login, so this is the first time this
specific user logs in. There aren't any objects matching this user's
partitionValue
- in our case, the user ID. When you start creating
objects, those objects write to Realm - both on the device, and in the
linked database you specified in the Sync configuration.
We never updated the client object model to have a _partition
field.
How does Realm know which objects the user has permission to read and write?
The realm file itself has the partitionValue
. You passed the user.id
as an environment object to the OpenSyncedRealmView, which uses it in the
configuration to open the realm. The objects that the user writes to the
realm file have that partitionValue
appended as the value for the
partition field you specified in the Sync configuration. If you look in
the linked database, you see both the Group
objects and the Item
objects contain a field _partition
. The value of this field is the
user ID of the logged-in user who created the objects:


And you can see in the Schema that Development Mode has
inferred, you now have a _partition
in the schema, even though you
haven't defined it explicitly in the client object model:
{ "title": "Group", "bsonType": "object", "required": [ "_id", "_partition" ], "properties": { "_id": { "bsonType": "objectId" }, "_partition": { "bsonType": "string" }, "items": { "bsonType": "array", "items": { "bsonType": "objectId" } } } }
Authenticate Users with MongoDB Realm
The LoginView maintains some state in order to display an activity indicator or error. It uses a reference to the Realm app instance passed in from above to log in when the Log in anonymously button is clicked.
In the LoginView, you can implement email/password authentication or another authentication provider. For simplicity, this example uses Anonymous authentication.
Once login is complete, the LoginView itself doesn't need to do anything more. Because the parent view is observing the Realm app, it will notice when the user authentication state has changed and decide to show something other than the LoginView.
/// Represents the login screen. We will have a button to log in anonymously. struct LoginView: View { // Hold an error if one occurs so we can display it. var error: Error? // Keep track of whether login is in progress. var isLoggingIn = false var body: some View { VStack { if isLoggingIn { ProgressView() } if let error = error { Text("Error: \(error.localizedDescription)") } Button("Log in anonymously") { // Button pressed, so log in isLoggingIn = true app!.login(credentials: .anonymous) { result in isLoggingIn = false if case let .failure(error) = result { print("Failed to log in: \(error.localizedDescription)") // Set error to observed property so it can be displayed self.error = error return } // Other views are observing the app and will detect // that the currentUser has changed. Nothing more to do here. print("Logged in") } }.disabled(isLoggingIn) } } }
The LogoutButton works just like the LoginView, but logs out instead of logging in:
/// A button that handles logout requests. struct LogoutButton: View { var isLoggingOut = false var body: some View { Button("Log Out") { guard let user = app!.currentUser else { return } isLoggingOut = true user.logOut() { error in isLoggingOut = false // Other views are observing the app and will detect // that the currentUser has changed. Nothing more to do here. print("Logged out") } }.disabled(app!.currentUser == nil || isLoggingOut) } }
Once logged in, the app follows the same flow as the local-only version. No additional changes are required to the original classes. They don't need to know whether or not you're using Realm Sync!
Feedback
Did you find this guide helpful? Found an issue? Have a question? Please let us know with the feedback form on the right side of the page.
Complete Code
In case you would like to copy and paste or examine the complete code with or without Realm Sync, see below.
Without Sync
import RealmSwift import SwiftUI // MARK: Models /// Random adjectives for more interesting demo item names let randomAdjectives = [ "fluffy", "classy", "bumpy", "bizarre", "wiggly", "quick", "sudden", "acoustic", "smiling", "dispensable", "foreign", "shaky", "purple", "keen", "aberrant", "disastrous", "vague", "squealing", "ad hoc", "sweet" ] /// Random noun for more interesting demo item names let randomNouns = [ "floor", "monitor", "hair tie", "puddle", "hair brush", "bread", "cinder block", "glass", "ring", "twister", "coasters", "fridge", "toe ring", "bracelet", "cabinet", "nail file", "plate", "lace", "cork", "mouse pad" ] /// An individual item. Part of a `Group`. final class Item: Object, ObjectKeyIdentifiable { /// The unique ID of the Item. `primaryKey: true` declares the /// _id member as the primary key to the realm. true) var _id: ObjectId (primaryKey: /// The name of the Item, By default, a random name is generated. var name = "\(randomAdjectives.randomElement()!) \(randomNouns.randomElement()!)" /// A flag indicating whether the user "favorited" the item. var isFavorite = false /// The backlink to the `Group` this item is a part of. "items") var group: LinkingObjects<Group> (originProperty: } /// Represents a collection of items. final class Group: Object, ObjectKeyIdentifiable { /// The unique ID of the Group. `primaryKey: true` declares the /// _id member as the primary key to the realm. true) var _id: ObjectId (primaryKey: /// The collection of Items in this group. var items = RealmSwift.List<Item>() } // MARK: Views // MARK: Main Views /// The main screen that determines whether to present the SyncContentView or the LocalOnlyContentView. /// For now, it always displays the LocalOnlyContentView. @main struct ContentView: SwiftUI.App { var body: some Scene { WindowGroup { LocalOnlyContentView() } } } /// The main content view if not using Sync. struct LocalOnlyContentView: View { // Implicitly use the default realm's objects(Group.self) Group.self) var groups ( var body: some View { if let group = groups.first { // Pass the Group objects to a view further // down the hierarchy ItemsView(group: group) } else { // For this small app, we only want one group in the realm. // You can expand this app to support multiple groups. // For now, if there is no group, add one here. ProgressView().onAppear { $groups.append(Group()) } } } } // MARK: Item Views /// The screen containing a list of items in a group. Implements functionality for adding, rearranging, /// and deleting items in the group. struct ItemsView: View { /// The group is a container for a list of items. Using a group instead of all items /// directly allows us to maintain a list order that can be updated in the UI. var group: Group /// The button to be displayed on the top left. var leadingBarButton: AnyView? var body: some View { NavigationView { VStack { // The list shows the items in the realm. List { ForEach(group.items) { item in ItemRow(item: item) }.onDelete(perform: $group.items.remove) .onMove(perform: $group.items.move) }.listStyle(GroupedListStyle()) .navigationBarTitle("Items", displayMode: .large) .navigationBarBackButtonHidden(true) .navigationBarItems( leading: self.leadingBarButton, // Edit button on the right to enable rearranging items trailing: EditButton()) // Action bar at bottom contains Add button. HStack { Spacer() Button(action: { // The bound collection automatically // handles write transactions, so we can // append directly to it. $group.items.append(Item()) }) { Image(systemName: "plus") } }.padding() } } } } /// Represents an Item in a list. struct ItemRow: View { var item: Item var body: some View { // You can click an item in the list to navigate to an edit details screen. NavigationLink(destination: ItemDetailsView(item: item)) { Text(item.name) if item.isFavorite { // If the user "favorited" the item, display a heart icon Image(systemName: "heart.fill") } } } } /// Represents a screen where you can edit the item's name. struct ItemDetailsView: View { var item: Item var body: some View { VStack(alignment: .leading) { Text("Enter a new name:") // Accept a new name TextField("New name", text: $item.name) .navigationBarTitle(item.name) .navigationBarItems(trailing: Toggle(isOn: $item.isFavorite) { Image(systemName: item.isFavorite ? "heart.fill" : "heart") }) }.padding() } }
With Sync
import RealmSwift import SwiftUI // MARK: MongoDB Realm (Optional) // The Realm app. Change YOUR_REALM_APP_ID_HERE to your Realm app ID. // If you don't have a Realm app and don't wish to use Sync for now, // you can change this to: // let app: RealmSwift.App? = nil let app: RealmSwift.App? = RealmSwift.App(id: YOUR_REALM_APP_ID_HERE) // MARK: Models /// Random adjectives for more interesting demo item names let randomAdjectives = [ "fluffy", "classy", "bumpy", "bizarre", "wiggly", "quick", "sudden", "acoustic", "smiling", "dispensable", "foreign", "shaky", "purple", "keen", "aberrant", "disastrous", "vague", "squealing", "ad hoc", "sweet" ] /// Random noun for more interesting demo item names let randomNouns = [ "floor", "monitor", "hair tie", "puddle", "hair brush", "bread", "cinder block", "glass", "ring", "twister", "coasters", "fridge", "toe ring", "bracelet", "cabinet", "nail file", "plate", "lace", "cork", "mouse pad" ] /// An individual item. Part of a `Group`. final class Item: Object, ObjectKeyIdentifiable { /// The unique ID of the Item. `primaryKey: true` declares the /// _id member as the primary key to the realm. true) var _id: ObjectId (primaryKey: /// The name of the Item, By default, a random name is generated. var name = "\(randomAdjectives.randomElement()!) \(randomNouns.randomElement()!)" /// A flag indicating whether the user "favorited" the item. var isFavorite = false /// The backlink to the `Group` this item is a part of. "items") var group: LinkingObjects<Group> (originProperty: } /// Represents a collection of items. final class Group: Object, ObjectKeyIdentifiable { /// The unique ID of the Group. `primaryKey: true` declares the /// _id member as the primary key to the realm. true) var _id: ObjectId (primaryKey: /// The collection of Items in this group. var items = RealmSwift.List<Item>() } // MARK: Views // MARK: Main Views /// The main screen that determines whether to present the SyncContentView or the LocalOnlyContentView. @main struct ContentView: SwiftUI.App { var body: some Scene { WindowGroup { // Using Sync? if let app = app { SyncContentView(app: app) } else { LocalOnlyContentView() } } } } /// The main content view if not using Sync. struct LocalOnlyContentView: View { // Implicitly use the default realm's objects(Group.self) Group.self) var groups ( var body: some View { if let group = groups.first { // Pass the Group objects to a view further // down the hierarchy ItemsView(group: group) } else { // For this small app, we only want one group in the realm. // You can expand this app to support multiple groups. // For now, if there is no group, add one here. ProgressView().onAppear { $groups.append(Group()) } } } } /// This view observes the Realm app object. /// Either direct the user to login, or open a realm /// with a logged-in user. struct SyncContentView: View { // Observe the Realm app object in order to react to login state changes. var app: RealmSwift.App var body: some View { if let user = app.currentUser { // If there is a logged in user, pass the user ID as the // partitionValue to the view that opens a realm. OpenSyncedRealmView().environment(\.partitionValue, user.id) } else { // If there is no user logged in, show the login view. LoginView() } } } /// This view opens a synced realm. struct OpenSyncedRealmView: View { // Use AsyncOpen to download the latest changes from // your Realm app before opening the realm. // Leave the `partitionValue` an empty string to get this // value from the environment object passed in above. YOUR_REALM_APP_ID_HERE, partitionValue: "", timeout: 4000) var asyncOpen (appId: var body: some View { switch asyncOpen { // Starting the Realm.asyncOpen process. // Show a progress view. case .connecting: ProgressView() // Waiting for a user to be logged in before executing // Realm.asyncOpen. case .waitingForUser: ProgressView("Waiting for user to log in...") // The realm has been opened and is ready for use. // Show the content view. case .open(let realm): ItemsView(group: { if realm.objects(Group.self).count == 0 { try! realm.write { realm.add(Group()) } } return realm.objects(Group.self).first! }(), leadingBarButton: AnyView(LogoutButton())).environment(\.realm, realm) // The realm is currently being downloaded from the server. // Show a progress view. case .progress(let progress): ProgressView(progress) // Opening the Realm failed. // Show an error view. case .error(let error): ErrorView(error: error) } } } struct ErrorView: View { var error: Error var body: some View { VStack { Text("Error opening the realm: \(error.localizedDescription)") } } } // MARK: Authentication Views /// Represents the login screen. We will have a button to log in anonymously. struct LoginView: View { // Hold an error if one occurs so we can display it. var error: Error? // Keep track of whether login is in progress. var isLoggingIn = false var body: some View { VStack { if isLoggingIn { ProgressView() } if let error = error { Text("Error: \(error.localizedDescription)") } Button("Log in anonymously") { // Button pressed, so log in isLoggingIn = true app!.login(credentials: .anonymous) { result in isLoggingIn = false if case let .failure(error) = result { print("Failed to log in: \(error.localizedDescription)") // Set error to observed property so it can be displayed self.error = error return } // Other views are observing the app and will detect // that the currentUser has changed. Nothing more to do here. print("Logged in") } }.disabled(isLoggingIn) } } } /// A button that handles logout requests. struct LogoutButton: View { var isLoggingOut = false var body: some View { Button("Log Out") { guard let user = app!.currentUser else { return } isLoggingOut = true user.logOut() { error in isLoggingOut = false // Other views are observing the app and will detect // that the currentUser has changed. Nothing more to do here. print("Logged out") } }.disabled(app!.currentUser == nil || isLoggingOut) } } // MARK: Item Views /// The screen containing a list of items in a group. Implements functionality for adding, rearranging, /// and deleting items in the group. struct ItemsView: View { /// The group is a container for a list of items. Using a group instead of all items /// directly allows us to maintain a list order that can be updated in the UI. var group: Group /// The button to be displayed on the top left. var leadingBarButton: AnyView? var body: some View { NavigationView { VStack { // The list shows the items in the realm. List { ForEach(group.items) { item in ItemRow(item: item) }.onDelete(perform: $group.items.remove) .onMove(perform: $group.items.move) }.listStyle(GroupedListStyle()) .navigationBarTitle("Items", displayMode: .large) .navigationBarBackButtonHidden(true) .navigationBarItems( leading: self.leadingBarButton, // Edit button on the right to enable rearranging items trailing: EditButton()) // Action bar at bottom contains Add button. HStack { Spacer() Button(action: { // The bound collection automatically // handles write transactions, so we can // append directly to it. $group.items.append(Item()) }) { Image(systemName: "plus") } }.padding() } } } } /// Represents an Item in a list. struct ItemRow: View { var item: Item var body: some View { // You can click an item in the list to navigate to an edit details screen. NavigationLink(destination: ItemDetailsView(item: item)) { Text(item.name) if item.isFavorite { // If the user "favorited" the item, display a heart icon Image(systemName: "heart.fill") } } } } /// Represents a screen where you can edit the item's name. struct ItemDetailsView: View { var item: Item var body: some View { VStack(alignment: .leading) { Text("Enter a new name:") // Accept a new name TextField("New name", text: $item.name) .navigationBarTitle(item.name) .navigationBarItems(trailing: Toggle(isOn: $item.isFavorite) { Image(systemName: item.isFavorite ? "heart.fill" : "heart") }) }.padding() } }