SkyPath

Shared instance that should be used for all operations.

Implement SkyPathDelegate methods to get notified when new data has been received from the server.

This will be a good place to query turbulence data and update layers on the map.

All methods will be called on the main thread.

Start the SDK. It will not track and provide data until started.

Should be called when the SkyPath service needs to start, for example on app start, only once. Until app is relaunched or after it was explicitly stopped by SkyPath.stop() no need to call it again.

The network connection is required for the very first start as it will validate the key on the server.

Check if SDK has been started already or not. Can be used before calling start().

Stops all SDK activities including communication with the server and turbulence detection.

Can be called if need to stop SkyPath service while the app is running. For example when the pilot is logged out from the app. Or the service should be stopped per the configuration, etc.

Callingstart() is required to start working again after stopping.

Configures what, how, and when data should be fetched from the server. All parameters have default values, so by default, it’s DataQuery()

You can update data query at any time and in both ways by setting a property only or a whole object. At first request, the whole data according to SkyPath.dataQuery is fetched and then only the new data that appeared (delta) is fetched to save network traffic.

When cached data expires or a delta can’t be received, the whole fresh data will be received again. When you change some query parameters SDK will start fetching fresh data immediately if needed. No need to force fetch manually.

Control the update data from the server frequency to reduce network traffic. Set none to not fetch any data temporarily. Each case could have its own time interval per request to fetch data and by default equals 1 min.

Fetch will not be triggered on change and data will be updated on the next time interval after change (for example in 1 min). Call SkyPath.shared.fetchData() to trigger a fetch as fast as possible if needed.

Can be updated at any time in the project. Value is stored across app launches until changed. Default is fast.

It determines the data history to be fetched from the server. So if it is set to .twoHours for example (the default one), there will be no data locally available for more than 2 hours ago. If need 4 hours of history, set SkyPath.dataHistoryTime to .fourHours.

When started, SDK fetches initial data from time back in time and then receives only updates since the last update. Changing from lower time to higher will require an API request to fetch data. When changing from higher to lower time, data could be available immediately as it was already included in the higher history time fetch. Alternatively, time can be set to .sixTime once to fetch 6 hours of history data always and then just query with a different time history to show on the map. Please note, that it will increase network traffic but will allow having more data available immediately and offline during changing time history.

Default is twoHours.

Last date when successfully received new data from the server.

Data is automatically fetched from the server by SDK out of the box, as well on changing data in dataQuery or dataUpdateFrequency.

Use this function to let SDK fetch new data from the server immediately. Do not call it frequently. A recommended usage is to call it when the pilot taps a refresh button if it is such. The fetched data result will be notified in corresponding delegate methods.

Get if specific area data is currently fetching from the server or not. The change of status is also notified via SkyPathDelegate.didUpdateFetchingStatus(fetching:areaType:dataType).

Get turbulence data using a query in locally cached data without making a server request. SDK fetches data from the server and caches it locally automatically.

Use TurbulenceQuery to get filtered data as a GeoJSON string or as an array of objects. It will query locally cached data received previously. It blocks the current thread, so using a separate background thread is recommended.

SkyPath.shared.dataHistoryTime determines the data history to be fetched from the server. By default, it is .twoHours. So if it was not changed, and query for .fourHours for example, there will be data only up to 2 hours. This is because no more data was fetched from the server.

H3 resolution 5 is used by SkyPath for the turbulence reports area. Each turbulence report covers ~252.9 square km hexagon area (as per the H3 resolutions table) and 1000 feet of altitude. Each hexagon is connected to the other so this allows for covering the area better. So one turbulence report covers for example FL370..<FL380 or FL380..<FL390.

Get turbulence polygons data using a query in locally cached data without making a server request. SDK fetches data from the server and caches it locally automatically.

Use TurbulencePolygonsQuery to get filtered data as a GeoJSON string. It will query locally cached data received previously. It blocks the current thread, so using a separate background thread is recommended.

SkyPath.shared.dataHistoryTime determines the data history to be fetched from the server. By default, it is .twoHours. So if it was not changed there are no polygons data for .fourHours for example. This is because polygons data is generated per each history time separately, so SDK needs to have it cached to return.

Get nowcast data using a query in locally cached data without making a server request. SDK fetches data from the server and caches it locally automatically.

Use NowcastQuery to get filtered data as a GeoJSON string or as an array of objects. It will query locally cached data received previously. It blocks the current thread, so using a separate background thread is recommended.

Nowcast data is fetched for all available NowcastHours.

H3 resolution 5 is used by SkyPath for the nowcast area. Each nowcast item covers ~252.9 square km hexagon area (as per the H3 resolutions table) and 1000 feet of altitude. Each hexagon is connected to the other so this allows for covering the area better. So one nowcast item covers for example FL370..<FL380 or FL380..<FL390.

Nowcast data is generated per specific forecast hours described in NowcastHours. When offline, some hours will become unavailable.

Use this function to check if available hours forecast is available at the moment or not. For example, data fetched at 06:00 will have all hours (6 hours) available. But if go offline, then every hour the farthest hour will become unavailable. And in 6 hours being offline no nowcast data will be available.

Get live flights data using a query in locally cached data without making a server request.

SDK fetches data from the server and caches it locally automatically.

Use LiveFlightQuery to get filtered data as a GeoJSON string or as an array of objects. It will query locally cached data received previously. It blocks the current thread, so using a separate background thread is recommended.

Get alerts manually when needed.

Alerts will be searched in locally cached data received per SkyPath.dataQuery configuration. No server request will be made here.

You can call it when needed, for example, on every location update, or by time intervals or distance passed. This will have all currently found turbulence alerts despite whether they were found in the previous query.

It blocks the current thread, so using a separate background thread is recommended.

Automatic monitoring. SDK will check for turbulence on every new location update.

When found, an alert will be reported via SkyPathDelegate.didReceiveAlert(alert:). This will not report the same turbulence alert multiple times in a row, but it could report the same alert that was reported previously if there were other alerts in between. So it will report only once in cases A1 A1 A1 A1 but will report 3 times in cases A1, A2, and A1.

Based on the AlertQuery properties, SDK filters server reports. All AlertQuery properties have default values. Configure it per your needs.

There are two modes: route and beam.

• Route mode is used when route line coordinates or a polygon are set in the query. It can use polygon or route line coordinates and width around to make a corridor.
• Beam mode is used when no route is provided. It is configured by angle span, and distance from the current location. When got a turbulence alert you can show it in the app with the local iOS notification if the app is in the background.

It is safe to call startMonitoringAlerts multiple times. However, it works as enable disable, so no need to call it again after starting monitoring until stopped monitoring and needs to start again.

You can also check SkyPath.shared.isMonitoringAlerts if need to call startMonitoringAlerts or stopMonitoringAlerts. When the AlertQuery changes you can call only startMonitoringAlerts(with:) with a new query without stopping it first.

Stop monitoring alerts in an automatic mode.

It is safe to call stopMonitoringAlerts multiple times. However, monitoring works as enabled and disable, so no need to call again after stopping. You can also check SkyPath.shared.isMonitoringAlerts if need to stop.

Check if auto monitoring has been started or it’s stopped/not started.

Call it when showing turbulence ahead notification to the pilot.

Set a current aircraft type using supported types from the SDK. Should not be nil. When it is not set the turbulence data will not be fetched from the server..

The turbulence severity level can be different for different aircraft types.

Usage example:

if let aircraft = SkyPath.shared.aircraft(byId: "B737") {
    SkyPath.shared.aircraft = aircraft
}

Get all aircraft supported by SkyPath.

Get an Aircraft by an id (ICAO code). Same as Aircraft(id:).

Update the current flight details. Flight is saved even across app launches.

Call it when a flight is set or updated, or removed in the app. Recoding data requires a flight when getting turbulence data, and other data is available without a flight.

Usage example:

let flight = Flight(dep: "ICAO", dest: "ICAO", fnum: "FLIGHT_NUMBER")
SkyPath.shared.startFlight(flight)

ICAO is the airport’s ICAO code. FLIGHT_NUMBER is a combination of the airline’s ICAO code and 1-4 digit number. When there is no such number, use ORIG-DEST-GUID, where ORIG is the ICAO code of the departure airport, DEST is the ICAO code of the destination airport and GUID is a globally unique identifier.

Current flight if any set by startFlight(_:).

Set when toggle SkyPath layer visibility, when showing or hiding the layer on the map.

Background location access is required to track turbulence and show notifications.

SDK version.

Current evironment.

If the device is in position.

The app auto-calibrates on its own now, we show the notification that it is calibrating and ready to record. When moved around, the app stops the recording but we do not show any note, since it could be intended. Following a minute in a stable position, the app recalibrates and will be ready to record again.

Data is not recorded when the iPad is horizontal. You can show a notification to the pilot on why it is not recording.

Data is not recorded when the iPad is horizontal. You can show a notification to the pilot on why it is not recording.

If there is a noise at the moment like moving the device out of the position. Data is not recorded when the iPad is in noise.

SDK has an internal logging system to help with debugging and solving issues.

SDK logs are stored in their own files along with other files used by the SDK.

Enables calculated pressure altitude for self.

When false, iPad’s GPS will be used for self altitude. When true, barometric pressure data will be used to calculate self altitude. Can be enabled and disabled at any time.

Self altitude is used for example in Turbulence Notifications to search within the vertical corridor.

Note: when true, baro forecast data will be periodically fetched from the server, and increase network traffic.

false by default.

Inject an external location for SDK to use in case the device’s location is not available.

SDK will use the device’s system location when available. Inject external location whenever the update is received.

Note: pass only a real location received from an external source.

In simulation mode, you can pass the simulated location to the SDK via simulateLocation(:) for testing purposes only.

Recording turbulence works only in the air, so SDK provides a simulation mode to test it on the ground.

Use it for DEV ENV only. It can be set by env: .dev(serverUrl: nil) in SkyPath.start(). By default when no env parameter is passed, the production server is used.
You can have some hidden developer options to enable/disable simulation mode for QA testing. Simulation mode can be enabled/disabled at any time.

Provide a simulated location for testing only. Should be set to simulation mode by enableSimulation(:).

Provide your own simulated location. The simplest way is to have an array of CLLocationCoordinate2D on the same in air altitude and pass it by a timer with 1-second time intervals.
You can use your flight simulation as well.

Enable SDK to send turbulence and events to the server. Otherwise simulated events will not be sent. The default is disabled.

Trigger a turbulence event by using a timer at some time intervals, or randomly during some time. Or just by having a test button or your own event to trigger.

Turbulence will not be tracked on the ground, so need an air-simulated location.

Simulate bad location by dropping location updates.

If simulate bad location is currently enabled or not.