Home

Welcome to the Mist iOS Location SDK Integration Guide!

Table of Contents

1. Introduction
2. System requirements
3. Installation
   • Installation using Cocoa-pods
   • Installation using Swift Package Manager
   • Installation - Manually using framework
4. Concepts
   1. App Permissions
   2. Mobile SDK Token
   3. Org Id
   4. Floor Plan
   5. Position Access Points
   6. WayFinding Paths
   7. Virtual Beacon
   8. Zones
   9. App Wakeup
5. Integration steps
6. Methods Available in IndoorLocationManager
7. FAQs

Introduction

The Indoor Location Service and Outdoor Location Service differ significantly. This is because most Outdoor Location Services rely on GPS and other Global Navigation Satellite Systems (GNSS), which are obstructed by buildings' roofs and walls. Consequently, GPS is not a suitable solution for our case study in terms of accuracy. To attain indoor location services, we utilize MistSDK, which employs BLE technology for indoor positioning, wayfinding systems, proximity notification, and other features.

MistSDKDR - Mist Software Development Kit Dead Reckoning.

By leveraging Mist's 16 vBLE antenna array Access point, Mist SDK facilitates an indoor blue dot experience. With this SDK, you will have the ability to determine the user's location and deliver proximity-based notifications utilizing Mist's patented vBeacon technology.

Why the word Dead Reckoning? MistSDK employs a dead reckoning technique to compute the user's current location. It does so by using their previous location and extrapolating it based on known and estimated speeds over elapsed time. This implies that DR is devised to make use of all available location data that a user had when connected and continues to function as though the client is connected, even when facing disconnections or interruptions in the connection.

Important features offered by our Mist SDK:

• Indoor Location
  • Providing the coordinates in the map for your app to draw the blue dot location of the device.
• Virtual Beacon Notification
  • A beacon, which is not physically present, but a virtual one. A virtual beacon that is added on the web portal and known by your app through the SDK. It provides notifications when the device is near the location of the virtual beacon.
• Virtual Zone notification
  • Zones are defined on the Mist portal as areas within a map. The SDK provides notifications on going into a zone.
• Wayfinding Path Information
  • Wayfinding paths are defined on the Mist portal. The SDK provides the coordinate information from the current blue dot to the nearest point in the paths, through the shortest path to a given coordinate in the same map. This information can be used by the app to draw the shortest route a user can take to a destination.

System requirements

1. Hardware Requirements:

   1. Mist Access Point with vBLE support (AP) - very important
      • Mist uses an AP with 16 vBLE Antennas to get the position of device in the floor.
   2. iOS Mobile Device: Since the iOS Simulator doesn't have Bluetooth support, it will not work properly. We need a physical device with BLE support for application testing and development with the SDK.

2. Software Requirements:

   1. Xcode: 13 or later.
   2. iOS deployment Target: 15.0 or later.
   3. Access to Mist Account
   4. Mobile SDK secret
   5. Org ID

Installation

Choose one of the following methods to add MistSDK to your project.

Installation using CocoaPods

Follow the steps to integrate CocoaPods in your Xcode project. See the CocoaPods Getting Started guide for more details.

1. Open the terminal and change directory to your project folder, and create and initialize Podfile using the commands below.

   $ cd ./project_folder_path
   

   • If pod is not installed, run the below command:

     $ sudo gem install cocoapods
     

2. Initialize project:

   $ pod init
   

   • This will create a folder and required files in the project directory.

3. Open the Podfile created and add the package to the target section in the pod file.

   source 'https://github.com/CocoaPods/Specs.git'
   source 'https://github.com/mistsys/mist-vble-ios-sdk.git'
   
   platform :ios, '15.0'
   
   target 'MyApp' do
     # Pods for MyApp
     pod 'MistSDK', '~> 4.0'
   end

4. Go back to the terminal and run the command in your project directory to complete the SDK installation with CocoaPods.

   $ pod install
   

5. Open projectname.xcworkspace and build. This way, you can get the benefit of the pod and its installed packages.

6. Add import MistSDK in Swift OR #import <MistSDK/MistSDK.h> in Objective-C to get started.

Installation using Swift Package Manager

You can add MistSDK via Swift Package Manager using either the Xcode UI or Package.swift.

Using Xcode (recommended):

1. Open your project in Xcode.
2. Go to File → Add Package Dependencies…
3. Enter the repository URL: https://github.com/mistsys/mist-vble-ios-sdk.git
4. Select the version rule (e.g., Up to Next Major from 4.0.0) and click Add Package.
5. Choose MistSDK as the package product and add it to your target.

Using Package.swift:

dependencies: [
    .package(url: "https://github.com/mistsys/mist-vble-ios-sdk.git", from: "4.0.0")
]

Installation - Manually using the framework

• For the latest SDK version, download the MistSDK.framework.
• Drag and drop the MistSDK.framework into the project file.
• In your Xcode project file, add MistSDK.framework to Targets → General → Frameworks, Libraries and Embedded Content → select Embed and Sign.
• Add import MistSDK in Swift OR #import <MistSDK/MistSDK.h> in Objective-C.

Concepts

Prerequisites

There are some important steps to be configured initially to get started with an SDK:

1. App Permissions.
2. Mobile SDK token.
3. Org ID
4. Floor Plan - (MistMap)
5. Position Access Points (APs) in the floor plan

And the following are necessary on a need basis:

1. Way-finding Paths
2. Virtual Beacons
3. Zones
4. App Wakeup

App Permissions

To proceed, our SDK gathers certain sensitive information, which is deemed necessary. For instance, the SDK leverages Bluetooth to scan for BLE devices and uses motion sensor data. Therefore, it is crucial to provide sufficient permissions to begin. These permissions include:

1. Bluetooth Permission:

   • Privacy - Bluetooth Always Usage Description
     • Bluetooth access required to scan Mist AP Beacon.

2. Motion Sensor Permission:

   • Privacy - Motion Usage Description
     • Motion sensor data is used to provide a more accurate indoor location estimate.

To provide those permissions open info.plist in source code mode and add the following snippet.

<key>NSBluetoothAlwaysUsageDescription</key>
<string>Bluetooth access required to scan Mist AP Beacon.</string>

<key>NSMotionUsageDescription</key>
<string>Motion sensor data is used to provide a more accurate indoor location estimate.</string>

Note: Location permission (NSLocationAlwaysAndWhenInUseUsageDescription) is only required if you intend to run the SDK in the background. See How to run MistSDK in Background for details.

Now we are done with adding permissions. The next step is to create a Mobile SDK token to enroll the device in the Mist Cloud.

How to run 'MistSDK' in Background

In order to run the MistSDK in background, you have to enable the below capabilities in the project under Signing & Capabilities:

1. Background Modes
   1. Uses Bluetooth LE accessory
   2. Background processing

Additionally, add the following location permission to your info.plist:

<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>Location access is required for indoor positioning while the app is in the background.</string>

Mobile SDK Token

Mobile SDK token is the secret key which can be created from the Mist portal. This key authenticates an SDK instance and identifies that it belongs to a specific organization in the Mist cloud.

What is the Mobile SDK Token used for? Mist provides indoor location services. The Mobile SDK Token ensures SDK instances are scoped to a specific organization in the Mist cloud.

Token creation steps:

• To create a Mobile SDK token, you should have registered with the Mist portal.
• Go to Organization → Mobile SDK.

• Create a new invitation. It will ask for the organization name and once you give the name and hit save, you will get your token.

Org ID

The Org ID is a unique identifier that links an SDK instance to a specific organization in the Mist cloud. It ensures that all operations and data are associated with the correct organization.

Steps to find your Org ID:

1. Open the Mist Portal.
2. Navigate to Organization → Admin → Settings from the left menu.

3. Locate the Organization ID displayed near the top of the page.
4. Click the copy button to copy the Org ID.

Note: The Org ID is generated by Juniper Mist and cannot be modified.

Floor plan - (MistMap)

• Our goal is to provide indoor location services. This requires a map, specifically a floor plan.
• In the Mist portal, we can upload the floor plans. We call these the MistMaps.

Maps Supported:

• Mist Map: Map Type (jpeg, png, gif)
• Micello
• Jibestream

Conversion from Mist Coordinates to other maps Jibestream:

• jibestreamX = (mistX * 1000) / mmpp
• jibestreamY = (mistY * 1000) / mmpp

Where mmpp is MilliMeterPerPixel which is specific to map and will be provided by Jibestream itself.

How to add the Floor Plan in Mist Portal:

• Go to Location → Live View – here it will show all of the existing floorplans. If there are none, it will prompt you to add a floorplan.

• To add a floor plan, click on the "Add FloorPlan" or "Import FloorPlan" button based on your requirements. You will be prompted to provide a name for the floor. Once you have entered the name, press Enter, and you will be asked to upload the floor plan image. Simply drag and drop the image into the designated area and click on the "Upload" button.

• The final step in configuring the floor plan is to add the PPM (Pixels per meter) value. This indicates the distance in meters that each pixel on the floor plan represents.

Positioning Access Points

Positioning the AP in the Mist Portal exactly as it is in the real world is crucial. Failing to do so will result in an inaccurate Mist Point.

How to position APs in the floor plan in the Mist Portal:

Go to Location → Live View → Setup Floorplan. From here you can see the list of APs that are claimed to that site and move them around to wherever you want.

Wayfinding Paths

Wayfinding paths can be created to help the location estimate gravitate towards the paths drawn out. The wayfinding paths can also be used by your app to draw the shortest route for wayfinding. To generate the path, we can use the Mist portal and define the route directly on the map:

• Go to Location → Live View → Choose the floor plan.
• Click the Wayfinding paths button.

• Draw paths in areas where there will be people walking and moving through; be sure to draw paths in every area where you intend to utilize the SDK clients. Make sure that all path segments are connected to each other.

For more information, see Adding Wayfinding Paths.

Virtual Beacons

vBeacons are a Mist-patented technology that enables the provision of proximity-related information. The advantage of vBeacons is that they can be placed anywhere on the floor plan without concerns about battery life or relocation issues. Similar to real beacons, ranging APIs can be used for vBeacons. It's important to note that these do not act as stand-ins for real beacons and are only for proximity-related notification information. Meaning that placing these vBeacons on your floorplan will not help increase accuracy.

To add the vBeacons:

• Go to Location → Live View → select the floor plan → click Beacons and Zones.

• Now the user can create and move the vBeacon wherever they want. All the green circles are vBeacons.

• You can customize the beacon according to your requirements. If you wish to remove a beacon, choose the "Remove" option, or to make modifications, select the "Edit" option.

• If you intend to edit a beacon, fill in the necessary details in the edit popup and save the changes. To delete a beacon, click the "Delete" button.

Zones

• A zone is a customized area defined on the Mist map that enables notifications to be sent to provide location-specific information to customers. We can send notifications when a user enters the specified zone in the Mist portal.
• To add zones, go to Location → Live View → select the floor plan → click Beacons and Zones.
• Click Add Location Zone and drag the area on the floor plan to create the zone.

As with virtual beacons, there are options to edit and delete the zones.

App Wakeup

App wakeup refers to the act of bringing the app back to an active state when it enters the range of a registered beacon. This feature is primarily related to the app itself and not the Mist SDK. However, you can initiate the SDK in the background when you receive the callback in the killed state and utilize it for analytics purposes instead of navigation or location.

For wakeup we are using the Apple CLBeaconRegion API using iBeacon in iOS. Apple has didEnterRegion and didExitRegion delegate methods in the Core Location package to handle such a scenario better.

Integration Steps:

1. Import the Mist SDK into your Swift file where you plan to use it.

   import MistSDK

2. Create a Mist.Configuration object with your Mist Organization ID (orgId) and SDK token (sdkToken). Optionally, you can provide a unique clientUUID, set a logLevel, and enable or disable logs.

   let sdkConfig = Mist.Configuration(orgId: <OrgId>,
                                      sdkToken: <Mobile SDK Token>,
                                      clientUUID: <ClientId>,   // Optional
                                      logLevel: <LogLevel>,     // Optional
                                      enableLog: <true/false>)  // Optional

   To use default configuration:

   let sdkConfig = Mist.Configuration.default(orgId: <OrgId>, sdkToken: <Mobile SDK Token>)

   Log levels:

   logLevel	Description
   DEBUG	Use for diagnosing issues and troubleshooting, or when running in a test environment to verify everything is running correctly.
   INFO	Standard log level indicating that something happened or the application entered a certain state.
   ERROR	Use when the application hits an issue preventing one or more functionalities from properly functioning.
   WARNING	Indicates that something unexpected happened — a problem or situation that might disturb one of the processes.
   VERBOSE	Very detailed information, intended only for development.

3. Initialize the IndoorLocationManager.

   The IndoorLocationManager is responsible for handling location updates. You need to get the shared instance of this manager.

   let mistManager = IndoorLocationManager.shared

4. Start the location SDK.

   Start the location SDK with the start(with:delegate:) method. This will initialize the SDK and begin location tracking. You will also need to assign a delegate to handle the location updates.

   mistManager.start(with: sdkConfig, delegate: self)

   Parameter	Description
   sdkConfig	The configuration object containing Mist credentials (orgId, sdkToken) and optional settings like clientUUID, logLevel, and enableLog.
   delegate	The object (typically your view controller) that implements the IndoorLocationDelegate protocol to handle events such as location updates and errors.

5. Once all steps are complete, SDK events will be delivered via didReceive(event: Mist.Event).

   IndoorLocationDelegate

   To handle all the MistSDK events efficiently, you need to override the didReceive() method and manage the incoming events using a switch statement with case conditions.

   func didReceive(event: Mist.Event) {
       switch event {
       case .eventName():
           // handle event here
       }
   }

   The following are the list of events:

   Event	Description
   OnReceivedClientInfo	Client information received after successful enrollment or name update.
   OnReceivedAllMaps	All site map data for the organization.
   OnMapUpdate	Current map data (triggered on first fix or floor change).
   OnUpdateVirtualBeaconList	Updated virtual beacon list for the current map.
   OnRelativeLocationUpdate	Updated position of the client on the current map.
   OnEnterZone	Client entered a defined zone.
   OnExitZone	Client exited a defined zone.
   OnRangeVirtualBeacon	Client is within range of a virtual beacon.
   OnError	An SDK error occurred.
   OnMessage	Current SDK status message.

   Example:

   func didReceive(event: Mist.Event) {
       switch event {
       case .onReceivedClientInfo(let client):
           debugPrint(">>> onReceivedClientInfo UUID => \(client.deviceId ?? "-")")
   
       case .onReceivedAllMaps(let maps):
           debugPrint(">>> onReceivedAllMaps \(maps.count)")
   
       case .onMapUpdate(let map):
           guard let url = map.url, let mapUrl = URL(string: url) else { return }
           currentMap = map
           delegate?.didUpdateMap(mapUrl)
           debugPrint(">>> onMapUpdate \(map.name ?? "-")")
   
       case .onUpdateVirtualBeaconList(let vBeacons):
           debugPrint(">>> onUpdateVirtualBeaconList \(vBeacons.count)")
   
       case .onRelativeLocationUpdate(let relativeLocation):
           guard let ppm = relativeLocation.map.ppm else { return }
           let location = CGPoint(x: relativeLocation.x * ppm, y: relativeLocation.y * ppm)
           debugPrint(">>> didUpdateRelativeLocation x = \(location.x) y = \(location.y) lat = \(relativeLocation.lat), lon = \(relativeLocation.lon)")
           delegate?.didUpdateLocation(location)
   
       case .onEnterZone(let zone):
           debugPrint(">>> didEnterZone \(zone.name!)")
       case .onExitZone(let zone):
           debugPrint(">>> didExitZone \(zone.name!)")
   
       case .onRangeVirtualBeacon(let vBeacon):
           debugPrint(">>> didRangeVirtualBeacon \(vBeacon.name!)")
   
       case .onError(let error):
           debugPrint(">>> didErrorOccur = \(error.localizedDescription)")
   
       default:
           break
       }
   }

Mist.Events

All events are received inside didReceive(event: Mist.Event). Use a switch statement to handle each case.

1. onReceivedClientInfo:

   When a client successfully completes enrollment or updates their name, you can retrieve their updated information.

   case onReceivedClientInfo(MistSDK.Mist.Client)

   Mist.Client

   Property	Datatype	Description
   name	String?	The name of the client.
   orgId	String?	The organization ID associated with the client.
   orgName	String?	The organization name associated with the client.
   deviceId	String?	The device ID of the client.

2. onReceivedAllMaps:

   To obtain all site maps, add the onReceivedAllMaps event. This event returns maps for all sites in the entire organization.

   case onReceivedAllMaps([MistSDK.Mist.Map])

   Mist.Map

   Property	Datatype	Description
   id	String?	The ID of the map.
   name	String?	The name of the map.
   siteId	String?	The site ID associated with the map.
   orgId	String?	The organization ID associated with the map.
   type	String?	The type of the map.
   locked	Bool?	Indicates whether the map is locked.
   originX	Double?	The x-coordinate origin of the map.
   originY	Double?	The y-coordinate origin of the map.
   width	Double?	The width of the map.
   height	Double?	The height of the map.
   ppm	Double?	The pixels per meter ratio of the map.
   widthM	Double?	The width of the map in meters.
   heightM	Double?	The height of the map in meters.
   createdTime	Int64?	The timestamp of when the map was created.
   modifiedTime	Int64?	The timestamp of when the map was last modified.
   url	String?	The URL of the map.
   thumbnailUrl	String?	The URL of the map thumbnail.
   wayFindingPath	MistSDK.Mist.Path?	The path data for wayfinding on the map.
   wallPath	MistSDK.Mist.Path?	The path data for walls on the map.
   siteSurveyPath	[MistSDK.Mist.Path]?	The path data for site survey on the map.
   wayfinding	MistSDK.Mist.Wayfinding?	Information about wayfinding on the map.
   latlngBr	MistSDK.Mist.LatlngBr?	The bottom-right latitude and longitude coordinates of the map.
   latlngTl	MistSDK.Mist.LatlngTl?	The top-left latitude and longitude coordinates of the map.
   drInternal	MistSDK.Mist.DRInternal?	Internal data related to DR.
   geoRefParamsv2	MistSDK.Mist.GeoRefParamsV2?	Georeferencing parameters for the map.
   orientation	Int?	The orientation of the map.
   occupancyLimit	Int64?	The occupancy limit of the map.
   intendedCoverageAreas	String : String?	The intended coverage areas of the map.

3. onMapUpdate:

   To get the current map data, add the onMapUpdate event to retrieve the latest map information.

   This event is triggered in the following situations:

   • Initially when the mobile receives relative location.
   • When the current floor plan has changed (if the user moves from one floor to another).

   case onMapUpdate(MistSDK.Mist.Map)

4. onUpdateVirtualBeaconList:

   To get all Virtual Beacons for the current map, add the onUpdateVirtualBeaconList event.

   case onUpdateVirtualBeaconList([MistSDK.Mist.VirtualBeacon])

   Mist.VirtualBeacon

   Property	Datatype	Description
   orgId	String?	The organization ID associated with the virtual beacon.
   siteId	String?	The site ID associated with the virtual beacon.
   mapId	String?	The map ID associated with the virtual beacon.
   vbId	String?	The ID of the virtual beacon.
   vbUUID	String?	The UUID of the virtual beacon.
   vbMajor	Int?	The major value of the virtual beacon.
   vbMinor	Int?	The minor value of the virtual beacon.
   power	Int?	The power of the virtual beacon.
   powerMode	String?	The power mode of the virtual beacon.
   message	String?	A message associated with the virtual beacon.
   createdTime	Int64?	The timestamp of when the virtual beacon was created.
   modifiedTime	Int64?	The timestamp of when the virtual beacon was last modified.
   tagId	String?	The tag ID associated with the virtual beacon.
   name	String?	The name of the virtual beacon.
   url	String?	The URL associated with the virtual beacon.
   position	MistSDK.VBeaconPosition?	The position information of the virtual beacon.
   additionalInfo	MistSDK.Mist.AdditionalInfo?	Additional information about the virtual beacon.

5. onRelativeLocationUpdate:

   To get the current relative position on the map, add the onRelativeLocationUpdate event. This event is triggered when the relative position of the client is updated.

   case onRelativeLocationUpdate(MistSDK.Mist.Point)

   Mist.Point

   Property	Datatype	Description
   map	MistSDK.Mist.Map	The map associated with the point.
   x	Double	The x-coordinate of the point.
   y	Double	The y-coordinate of the point.
   lat	Double	The latitude of the point.
   lon	Double	The longitude of the point.
   latency	Int64	The latency associated with the point.
   heading	Double	The heading (direction) of the point.
   speed	Double	The speed associated with the point.
   hasMotion	Bool	Indicates whether the point has motion.

6. onEnterZone:

   To receive zone notifications on enter, add onEnterZone to monitor when the client moves into a particular zone area.

   case onEnterZone(MistSDK.Mist.Zone)

7. onExitZone:

   To receive zone notifications on exit, add onExitZone to monitor when the client moves out of a particular zone area.

   case onExitZone(MistSDK.Mist.Zone)

   Mist.Zone

   Property	Datatype	Description
   name	String?	The name of the zone.
   timestamp	String?	The timestamp associated with the zone.
   origin	String?	The origin of the zone.
   level	Int?	The level of the zone.
   recipient	String?	The recipient of the zone.
   recipientId	String?	The ID of the recipient of the zone.
   userId	String?	The ID of the user associated with the zone.
   zoneId	String?	The ID of the zone.
   mapId	String?	The ID of the map associated with the zone.
   siteId	String?	The site ID associated with the zone.
   orgId	String?	The organization ID associated with the zone.
   clientType	String?	The type of client associated with the zone.
   isRandom	Bool?	Indicates if the zone is random.
   zonePosition	MistSDK.ZonePosition?	The position information of the zone.
   trigger	MistSDK.Mist.ZoneTrigger?	The trigger associated with the zone.
   time	String?	The time associated with the zone.
   sinceTime	String?	The since time associated with the zone.
   timeEpoch	Int64?	The epoch time associated with the zone.
   sinceTimeEpoch	Int64?	The epoch time since associated with the zone.
   sessionId	String?	The session ID associated with the zone.
   duration	Int64?	The duration associated with the zone.

8. onRangeVirtualBeacon:

   To receive notifications when the client is within range of a Virtual Beacon, add onRangeVirtualBeacon to monitor proximity.

   case onRangeVirtualBeacon(MistSDK.Mist.VirtualBeacon)

9. onError:

   To receive notifications when the SDK faces any issues, add onError. This event is triggered if the SDK encounters an error.

   case onError(let error)

   ErrorType

   Error	Description	Suggested Action
   invalidSDKToken	The SDK token provided is incorrect or invalid.	Verify the token in the Mist portal and update your configuration.
   sdkNotStarted	The SDK was not started.	Call mistManager.start(with:delegate:) before using other SDK features.
   notConnected	MistSDK is not connected to the cloud.	Check network connectivity and retry start().
   authorizationFailure	Authorization failure.	Re-verify your Org ID and SDK token.
   clientEnrollmentFailed	There was an error in Client Enrollment.	Retry or check network conditions.
   clientUpdationFailed	Failed to save client name.	Retry saveClient(name:) when network is available.
   unableToGetClientDetails	There was an error in fetching client details.	Call getClientInformation() again after a brief delay.
   mapGraphDataNotAvailable	Map data not available.	Ensure the floor plan and APs are configured correctly in the Mist portal.
   noBleFound	MistSDK is stopped. No vBLE Beacon found.	Ensure you are within range of a Mist AP with vBLE support.
   noBleBeaconFound	PreCheck - No Mist BLE Beacon found.	Ensure Bluetooth is enabled and you are within AP range.

10. When you are done, stop the SDK to release resources:

    mistManager.stop()

Methods Available in IndoorLocationManager

1. start(with:delegate:)
2. stop()
3. getWayfindingPath(to:)
4. saveClient(name:)
5. getClientInformation()
6. clientUUID

1 — start(with:delegate:)

• This method will start the MistSDK.

• Usage:

  mistManager.start(with: sdkConfig, delegate: self)

2 — stop()

• This method will stop MistSDK.

• It doesn't take any arguments and won't return anything.

• Usage:

  mistManager.stop()

3 — getWayfindingPath(to:)

• This method returns a list of nodes representing the shortest path to the given destination.

• It uses Dijkstra's shortest path algorithm — one of the most widely used graph traversal algorithms — to calculate the optimal route from the user's current position to the destination.

• This is an instance method — call it on the shared manager instance.

• Pass a MistSDK.MistPosition object as the destination. Returns [MistSDK.Mist.Node].

• Usage:

  let nodes = mistManager.getWayfindingPath(to: MistPosition(x: 10, y: 10))

Best Practices: For accurate and reliable wayfinding results, ensure that the paths drawn on the Mist portal are:

• Well connected — all path segments must be linked with no gaps or dead ends.
• Accurate — paths should closely follow the real-world walkable areas on the floor plan.
• Complete — paths should cover every area where users are expected to navigate.

Poorly connected or inaccurate paths will result in incorrect or suboptimal routes.

4 — saveClient(name:)

• Saves the user's display name to the Mist server. Once saved, the user is identifiable on the map by this name.

• Usage:

  mistManager.saveClient(name: "<username>")

5 — getClientInformation()

• Fetches the current client's information from the server. The result is delivered via didReceive(event:) as case onReceivedClientInfo(let client).

• Usage:

  mistManager.getClientInformation()

6 — clientUUID

• This property returns the current Mist user UUID assigned by the server.

• Usage:

  let mistUUID = mistManager.clientUUID