Session Store (Alpha)

To obtain a reference to the session store, you need to override the func on(sessionStoreAvailable store: HMSSessionStore) function of the HMSUpdateListener protocol. Once you get the reference to the store you can save it in your app for accessing later.

Setting a value for a specific key

Use the set API to assign a value to a specific key. Once a value is assigned, it will be available for other peers in the room who are observing this key.

store.set("new value", forKey: "my key") { finalValue, error in
    if error == nil {
        print("Value was updated successfuly to: \(finalValue)")
    }
}

Retrieving a value for a specific key

Retrieve the current value and receive updates

Most of the time the application is interested not just in a current value of a key but also any updates to that value. To obtain the initial value and receive updates, use the observeChanges API. It takes a list of keys to observe and a closure that will be called for initial value and every time an update is received.

store.observeChanges(forKeys: ["date", "time"]) { [weak self] key, value in
    switch key {
    case "date":
        self?.onDateUpdated(value as? String)
    case "time":
        self?.onTimeUpdated(value as? String)
    default:
        break

    }
}

You can have multiple observers running concurrently.

Managing the lifecycle of observers

During the lifecycle of the app, you may need to subscribe and unsubscribe for value updates. To unsubscribe we first need to get the observer reference by passing a completion closure to the observeChanges API:

store.observeChanges(forKeys: ["key", "key2"], changeObserver: { [weak self] key, value in
    // ... update handling code
}) { [weak self] observer, error in
    self?.observer = observer
}

Later when the observer is no longer needed call store.removeObserver(observer) API to stop receiving update.

Retrieve the current value once

Use the object(forKey:completion) API if your application does not require updates for the key.

store.object(forKey: "my key") { value, error in
    if error == nil {
        print("Value was fetched successfuly: \(value)")
    }
}

How to Store Common Objects/Information in the Room that is Shared across all Participants

HMSRoomModel instance exposes a shared dictionary called sharedStore. You can use this to store any objects or primitives and they will be available to all participants in the room. You store key value pairs to this dictionary like following.

As an example, let's see how to store Participant's ID in Shared Storage of the Room so that Everyone in the Meeting can access this ID

guard let highlightedStudent = (roomModel.peerModels.first{$0.name == "Pawan"}) else { return }
roomModel.sharedStore["Highlighted Participant ID"] = highlightedStudent.id

How would other Participants use this Shared ID?

Step 1. Make sure that room model observes this key like following:

roomModel.beginObserving(keys: ["Highlighted Participant ID"])

You generally do this at the start of the meeting, so that you can begin observing any changes for that key. If at any point in the call, you want to stop observing changes for a particular key call stopObserving(keys:) method passing an array of keys that you no more want to observe.

Step 2. Display highlighted student

VStack {
    if let highlightedStudentID = roomModel.sharedStore?["Highlighted Participant ID"] as? String,
       let highlightedStudent = roomModel.peerModels.first(where: {$0.id == highlightedStudentID}) {
        
           HMSVideoTrackView(peer: highlightedStudent)
    }
}

Note that sharedStore dictionary is Published property of room model, thus any changes in this dictionary values reflect in your SwiftUI views automatically.