Build Your First iOS Mobile App Using Realm, SwiftUI, & Combine

1
import SwiftUI
2
import RealmSwift:
3
4
let app = App(id: "tasktracker-xxxxx") // TODO: Set the Realm application ID
5
6
@main
7
struct swiftui_realmApp: SwiftUI.App {
8
   @StateObject var state = AppState()
9
10
   var body: some Scene {
11
      WindowGroup {
12
            ContentView()
13
            .environmentObject(state)
14
      }
15
   }
16
}

1
class AppState: ObservableObject {
2
   var loginPublisher = PassthroughSubject<RealmSwift.User, Error>()
3
   var logoutPublisher = PassthroughSubject<Void, Error>()
4
   let userRealmPublisher = PassthroughSubject<Realm, Error>()
5
   var cancellables = Set<AnyCancellable>()
6
7
   @Published var shouldIndicateActivity = false
8
   @Published var error: String?
9
10
   var user: User?
11
}

1
init() {
2
loginPublisher
3
   .receive(on: DispatchQueue.main)
4
   .flatMap { user -> RealmPublishers.AsyncOpenPublisher in
5
         self.shouldIndicateActivity = true
6
         var realmConfig = user.configuration(partitionValue: "user=\(user.id)")
7
         realmConfig.objectTypes = [User.self, Project.self]
8
         return Realm.asyncOpen(configuration: realmConfig)
9
   }
10
   .receive(on: DispatchQueue.main)
11
   .map {
12
         self.shouldIndicateActivity = false
13
         return $0
14
   }
15
   .subscribe(userRealmPublisher)
16
   .store(in: &self.cancellables)
17
}

1
import RealmSwift
2
3
class User: Object {
4
   @objc dynamic var _id: String = UUID().uuidString
5
   @objc dynamic var _partition: String = ""
6
   @objc dynamic var name: String = ""
7
   let memberOf = RealmSwift.List<Project>()
8
9
   override static func primaryKey() -> String? {
10
         return "_id"
11
   }
12
}

1
import RealmSwift
2
3
class Project: EmbeddedObject {
4
   @objc dynamic var name: String?
5
   @objc dynamic var partition: String?
6
   convenience init(partition: String, name: String) {
7
         self.init()
8
         self.partition = partition
9
         self.name = name
10
   }
11
}

1
import RealmSwift
2
3
enum TaskStatus: String {
4
   case Open
5
   case InProgress
6
   case Complete
7
}
8
9
class Task: Object {
10
   @objc dynamic var _id: ObjectId = ObjectId.generate()
11
   @objc dynamic var _partition: String = ""
12
   @objc dynamic var name: String = ""
13
   @objc dynamic var owner: String?
14
   @objc dynamic var status: String = ""
15
   override static func primaryKey() -> String? {
16
         return "_id"
17
   }
18
19
   var statusEnum: TaskStatus {
20
         get {
21
            return TaskStatus(rawValue: status) ?? .Open
22
         }
23
         set {
24
            status = newValue.rawValue
25
         }
26
   }
27
28
   convenience init(partition: String, name: String) {
29
         self.init()
30
         self._partition = partition
31
         self.name = name
32
   }
33
}

1
struct ContentView: View {
2
   @EnvironmentObject var state: AppState
3
4
   var body: some View {
5
         NavigationView {
6
            ZStack {
7
               VStack {
8
                     if state.loggedIn && state.user != nil {
9
                        if state.user != nil {
10
                           ProjectsView()
11
                        }
12
                     } else {
13
                        LoginView()
14
                     }
15
                     Spacer()
16
                     if let error = state.error {
17
                        Text("Error: \(error)")
18
                           .foregroundColor(Color.red)
19
                     }
20
               }
21
               if state.shouldIndicateActivity {
22
                     ProgressView("Working With Realm")
23
               }
24
            }
25
            .navigationBarItems(leading: state.loggedIn ? LogoutButton() : nil)
26
         }
27
   }
28
}

1
private func login(username: String, password: String) {
2
   if username.isEmpty || password.isEmpty {
3
         return
4
   }
5
   self.state.error = nil
6
   state.shouldIndicateActivity = true
7
   app.login(credentials: .emailPassword(email: username, password: password))
8
         .receive(on: DispatchQueue.main)
9
         .sink(receiveCompletion: {
10
            state.shouldIndicateActivity = false
11
            switch $0 {
12
            case .finished:
13
               break
14
            case .failure(let error):
15
               self.state.error = error.localizedDescription
16
            }
17
         }, receiveValue: {
18
            self.state.error = nil
19
            state.loginPublisher.send($0)
20
         })
21
         .store(in: &state.cancellables)
22
}

1
private func signup(username: String, password: String) {
2
   if username.isEmpty || password.isEmpty {
3
         return
4
   }
5
   self.state.error = nil
6
   state.shouldIndicateActivity = true
7
   app.emailPasswordAuth.registerUser(email: username, password: password)
8
         .receive(on: DispatchQueue.main)
9
         .sink(receiveCompletion: {
10
            state.shouldIndicateActivity = false
11
            switch $0 {
12
            case .finished:
13
               break
14
            case .failure(let error):
15
               self.state.error = error.localizedDescription
16
            }
17
         }, receiveValue: {
18
            self.state.error = nil
19
            self.presentationMode.wrappedValue.dismiss()
20
         })
21
         .store(in: &state.cancellables)
22
}

1
struct LogoutButton: View {
2
   @EnvironmentObject var state: AppState
3
   var body: some View {
4
         Button("Log Out") {
5
            state.shouldIndicateActivity = true
6
            app.currentUser?.logOut()
7
               .receive(on: DispatchQueue.main)
8
               .sink(receiveCompletion: { _ in
9
               }, receiveValue: {
10
                     state.shouldIndicateActivity = false
11
                     state.logoutPublisher.send($0)
12
               })
13
               .store(in: &state.cancellables)
14
         }
15
         .disabled(state.shouldIndicateActivity)
16
   }
17
}

1
var body: some View {
2
   VStack(spacing: Dimensions.padding) {
3
         if let projects = state.user?.memberOf {
4
            ForEach(projects, id: \.self) { project in
5
               HStack {
6
                     LabeledButton(label: project.partition ?? "No partition",
7
                                    text: project.name ?? "No project name") {
8
                        showTasks(project)
9
                     }
10
               }
11
            }
12
         }
13
         Spacer()
14
         if let tasksRealm = tasksRealm {
15
            NavigationLink( destination: TasksView(realm: tasksRealm, projectName: projectName),
16
                           isActive: $showingTasks) {
17
               EmptyView() }
18
         }
19
   }
20
   .navigationBarTitle("Projects", displayMode: .inline)
21
   .toolbar {
22
         ToolbarItem(placement: .bottomBar) {
23
            Button(action: { self.showingSheet = true }) {
24
               ManageTeamButton()
25
            }
26
         }
27
   }
28
   .sheet(isPresented: $showingSheet) { TeamsView() }
29
   .padding(.all, Dimensions.padding)
30
}

1
userRealmPublisher
2
   .sink(receiveCompletion: { result in
3
         if case let .failure(error) = result {
4
            self.error = "Failed to log in and open realm: \(error.localizedDescription)"
5
         }
6
   }, receiveValue: { realm in
7
         self.user = realm.objects(User.self).first
8
   })
9
   .store(in: &cancellables)

1
func showTasks(_ project: Project) {
2
   state.shouldIndicateActivity = true
3
   let realmConfig = app.currentUser?.configuration(partitionValue: project.partition ?? "")
4
   guard var config = realmConfig else {
5
         state.error = "Cannot get Realm config from current user"
6
         return
7
   }
8
   config.objectTypes = [Task.self]
9
   Realm.asyncOpen(configuration: config)
10
         .receive(on: DispatchQueue.main)
11
         .sink(receiveCompletion: { result in
12
            state.shouldIndicateActivity = false
13
            if case let .failure(error) = result {
14
               self.state.error = "Failed to open realm: \(error.localizedDescription)"
15
            }
16
         }, receiveValue: { realm in
17
            self.tasksRealm = realm
18
            self.projectName = project.name ?? ""
19
            self.showingTasks = true
20
            state.shouldIndicateActivity = false
21
         })
22
         .store(in: &self.state.cancellables)
23
}

1
NavigationLink(
2
   destination: TasksView(realm: tasksRealm, projectName: projectName),
3
   isActive: $showingTasks) {
4
         EmptyView()
5
   }

1
var body: some View {
2
   VStack {
3
         if let tasks = tasks {
4
            List {
5
               ForEach(tasks.freeze()) { task in
6
                     if let tasksRealm = tasks.realm {
7
                        TaskView(task: (tasksRealm.resolve(ThreadSafeReference(to: task)))!)
8
                     }
9
               }
10
               .onDelete(perform: deleteTask)
11
            }
12
         } else {
13
            Text("Loading...")
14
         }
15
         if let lastUpdate = lastUpdate {
16
            LastUpdate(date: lastUpdate)
17
         }
18
   }
19
   .navigationBarTitle("Tasks in \(projectName)", displayMode: .inline)
20
   .navigationBarItems(trailing: Button(action: { self.showingSheet = true }) {
21
         Image(systemName: "plus.circle.fill")
22
            .renderingMode(.original)
23
24
   })
25
   .sheet(isPresented: $showingSheet) { AddTaskView(realm: realm) }
26
   .onAppear(perform: loadData)
27
   .onDisappear(perform: stopWatching)
28
}

1
ForEach(tasks.freeze()) { task in ...

1
TaskView(task: (tasksRealm.resolve(ThreadSafeReference(to: task)))!)

1
func loadData() {
2
   tasks = realm.objects(Task.self).sorted(byKeyPath: "_id")
3
   realmNotificationToken = realm.observe { _, _ in
4
         lastUpdate = Date()
5
   }
6
}

1
func stopWatching() {
2
   if let token = realmNotificationToken {
3
         token.invalidate()
4
   }
5
}

1
func deleteTask(at offsets: IndexSet) {
2
   do {
3
         try realm.write {
4
            guard let tasks = tasks else {
5
               return
6
            }
7
            realm.delete(tasks[offsets.first!])
8
         }
9
   } catch {
10
         state.error = "Unable to open Realm write transaction"
11
   }
12
}

1
var body: some View {
2
   Button(action: { self.showingUpdateSheet = true }) {
3
         HStack(spacing: Dimensions.padding) {
4
            switch task.statusEnum {
5
            case .Complete:
6
               Text(task.name)
7
                     .strikethrough()
8
                     .foregroundColor(.gray)
9
               Spacer()
10
               Image(systemName: "checkmark.square")
11
                     .foregroundColor(.gray)
12
            case .InProgress:
13
               Text(task.name)
14
                     .fontWeight(.bold)
15
               Spacer()
16
               Image(systemName: "tornado")
17
            case .Open:
18
               Text(task.name)
19
               Spacer()
20
            }
21
         }
22
   }
23
   .sheet(isPresented: $showingUpdateSheet) {
24
         UpdateTaskView(task: task)
25
   }
26
   .padding(.horizontal, Dimensions.padding)
27
}

1
var body: some View {
2
   NavigationView {
3
         VStack {
4
            List {
5
               ForEach(members) { member in
6
                     LabeledText(label: member.id, text: member.name)
7
               }
8
               .onDelete(perform: removeTeamMember)
9
            }
10
            Spacer()
11
         }
12
         .navigationBarTitle(Text("My Team"), displayMode: .inline)
13
         .navigationBarItems(
14
            leading: Button(
15
               action: { self.presentationMode.wrappedValue.dismiss() }) { Image(systemName: "xmark.circle") },
16
            trailing: Button(action: { self.showingAddTeamMember = true }) { Image(systemName: "plus.circle.fill")
17
               .renderingMode(.original)
18
            }
19
         )
20
   }
21
   .sheet(isPresented: $showingAddTeamMember) {
22
         // TODO: Not clear why we need to pass in the environmentObject, appears that it may
23
         // be a bug – should test again in the future.
24
         AddTeamMemberView(refresh: fetchTeamMembers)
25
            .environmentObject(state)
26
   }
27
   .onAppear(perform: fetchTeamMembers)
28
}

1
func fetchTeamMembers() {
2
   state.shouldIndicateActivity = true
3
   let user = app.currentUser!
4
5
   user.functions.getMyTeamMembers([]) { (result, error) in
6
      DispatchQueue.main.sync {
7
            state.shouldIndicateActivity = false
8
            guard error == nil else {
9
               state.error = "Fetch team members failed: \(error!.localizedDescription)"
10
               return
11
            }
12
            guard let result = result else {
13
               state.error = "Result from fetching members is nil"
14
               return
15
            }
16
            self.members = result.arrayValue!.map({ (bson) in
17
               return Member(document: bson!.documentValue!)
18
            })
19
      }
20
   }
21
}

1
func removeTeamMember(at offsets: IndexSet) {
2
   state.shouldIndicateActivity = true
3
   let user = app.currentUser!
4
   let email = members[offsets.first!].name
5
   user.functions.removeTeamMember([AnyBSON(email)]) { (result, error) in
6
      DispatchQueue.main.sync {
7
            state.shouldIndicateActivity = false
8
            if let error = error {
9
               self.state.error = "Internal error, failed to remove member: \(error.localizedDescription)"
10
            } else if let resultDocument = result?.documentValue {
11
               if let resultError = resultDocument["error"]??.stringValue {
12
                  self.state.error = resultError
13
               } else {
14
                  print("Removed team member")
15
                  self.fetchTeamMembers()
16
               }
17
            } else {
18
               self.state.error = "Unexpected result returned from server"
19
            }
20
      }
21
   }
22
}