I've been developer super complex application. If there is internet disconnections the app will clear the existing data and wait for internet availability. Once internet is available, it'll re launch the functionalities like connecting web socket, existing order check etc.
I was used
DispatchQueue.main.async { }
The app worked perfect. But when I used
Task(priority: .userInitiated, operation: {}
from applicationDidFinishLaunching for using async functions call. In all places I'm using Task(priority: .userInitiated, operation: {} only also I'm sure, I didn't used at least a detached task Task.detached(operation: .userInitiated).
Error:
The app will log all events. The logs are printing like Firebase console. If there is internet disconnection & re-connection the app will lose the main thread of logsVC without any error.
Internet Re-connection:
I'm reconnecting internet by identifying WKWebSocket disconnection because of internet failure.
It's all fine but once internet available, then app will lose its main thread. How can I resolve this issue?
func webSocket(_ webSocket: WebSocket, didFailedWith error: Error) {
let error = error as NSError
switch error.code {
case 401: // Authentication Failed.
Task(priority: .userInitiated) {
logprint("Refresh \(webSocket.name) token to reconnect....")
do {
try await self.refreshToken()
if try await self.connectWebSocket() == false {
log("Something went wrong on \(#file) at line \(#line)", .failure)
}
} catch {
log("\(webSocket.name) conting websocket again failed...", error)
}
}
case 101: // connection reset by peer
Task(priority: .userInitiated) {
await webSocket.networkFailed()
}
default:
log("\(webSocket.name) Rejected...", error)
}
}
func networkFailed() async {
self.isConnected = false
await App.shared.reloadWhenInternetAvailable()
}
App:
func reloadWhenInternetAvailable() async {
log("Reload when internet is available.... \(self.isNetworkAvailable)", .info)
guard self.isNetworkAvailable else { return }
let t1 = Time.now
guard self.appLaunchedAt.needsWebSocketConnection || t1.needsWebSocketConnection else { return }
Calendar.default.cancelTimer()
self.isNetworkAvailable = false
let t = t1 - self.appLaunchedAt
log("Internet disconnected after \(t.conventionLabel)", .warning)
await MainActor.run {
self.delegate.status = .internetNotAvailable
UserNotifications.error("Internet is disconnected...").fire(.internet)
}
await Reachablity.shared.waitUntilInternetAvailable()
let t2 = Time.now - t1
// This is not printing only sometimes. If Internet available around 2 hours then this is not printing. For less time, the below log is printing in the GUI.
log("Internet connected after \(t2.conventionLabel)", .success)
await MainActor.run {
UserNotifications.ID.internet.revoke()
UserNotifications.success("Internet reconnected!").fire(.temprory)
}
await delay(2)
await self.relaunch()
}
Since the app lost it's main thread only after internet availability identified. So Here is the, Reachablity Functions:
public func waitUntilInternetAvailable() async {
if self.isNetworkLoopRunning {
logprint("Loop started... \(Time.now.debugDescription)")
while !self.isConnectedToNetwork {
await delay(milli: 1)
}
logprint("Loop finished... \(Time.now.debugDescription)")
} else {
await self.checkNetworkLoop()
}
}
private func checkNetworkLoop() async {
logprint("Wait... \(Time.now.debugDescription)")
self.isNetworkLoopRunning = true
while await !self.isAvailable() {
await delay(3)
}
self.isNetworkLoopRunning = false
}
public func isAvailable() async -> Bool {
do {
var req = URLRequest(url: self.url)
req.httpMethod = "GET"
req.timeoutInterval = 3.0
req.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData
_ = try await URLSession.shared.data(for: req)
await MainActor.run {
self.isConnectedToNetwork = true
}
return true
} catch {
let error = error as NSError
if !self.isNetworkLostError(error) {
let error = error as NSError
log("The network checking error code is unidentified.", error)
}
await MainActor.run {
self.isConnectedToNetwork = false
}
return false
}
}
Delay:
func delay(_ seconds: UInt64) async {
do {
try await Task.sleep(nanoseconds: seconds * 1_000_000_000)
} catch {
print("Error: Waiting for the time interval(\(seconds)) failed with error \(error.localizedDescription)")
}
}
// 0 to 10; 5 = 500 milli
func delay(milli seconds: UInt64) async {
do {
try await Task.sleep(nanoseconds: seconds * 100_000_000)
} catch {
print("Error: Waiting for the time interval(0.\(seconds)) failed with error \(error.localizedDescription)")
}
}
After long weeks I figured out the issue myself. The issue is,
Task.detached { @MainActor
reloadData(forRowIndexes: [index], columnIndexes: [0])
}
Because of using Task.detached { @MainActor the app didn't crashed when the index is out of bounds. But It's internally crashed without any warnings.
DispatchQueue.main.async {
self.reloadData(forRowIndexes: [index], columnIndexes: [0])
}
Perfectly crashes the app with xcode logs.
Root cause:
In my NSTableView logs are dynamically inserting to main thread. So the time of app freeze, I can see the new AppLog in the place of 2nd or 3rd row but It's supposed to be 1st.
App crash:
*** Terminating app due to uncaught exception 'NSTableViewException', reason: 'NSTableView error inserting/removing/moving row 69 (numberOfRows: 68).'
If I not open the LogsVC, the app continuously works so fine. So clearly the main coding issue lies on the Logs TableView Reload method.