Many iOS applications obtain data via HTTP web services that return JSON documents. For example, the following code uses the HTTP-RPC WSWebServiceProxy class to invoke a simple web service that returns a simulated list of users as JSON. The results are stored as a dictionary and presented in a table view:
class UserViewController: UITableViewController {
var users: [[String: Any]]! = nil
...
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
if (users == nil) {
// Load the data from the server
AppDelegate.serviceProxy.invoke("GET", path: "/users") { result, error in
if (error == nil) {
self.users = result as? [[String: Any]]
self.tableView.reloadData()
}
}
}
}
...
}This works fine when both the device and the service are online, but it fails if either one is not. In some cases this may be acceptable, but other times it might be preferable to show the user the most recent response when more current data is not available.
To facilitate offline support, the response data must be cached. However, since writing to the file system is a potentially time-consuming operation, it should be done in the background to avoid blocking the main (UI) thread. Here, the data is written using an operation queue to ensure that access to it is serialized:
class UserViewController: UITableViewController {
var users: [[String: Any]]! = nil
var userCacheURL: URL?
let userCacheQueue = OperationQueue()
override func viewDidLoad() {
super.viewDidLoad()
...
if let cacheURL = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first {
userCacheURL = cacheURL.appendingPathComponent("users.json")
}
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
if (users == nil) {
// Load the data from the server
AppDelegate.serviceProxy.invoke("GET", path: "/users") { result, error in
if (error == nil) {
self.users = result as? [[String: Any]]
self.tableView.reloadData()
// Write the response to the cache
if (self.userCacheURL != nil) {
self.userCacheQueue.addOperation() {
if let stream = OutputStream(url: self.userCacheURL!, append: false) {
stream.open()
JSONSerialization.writeJSONObject(result!, to: stream, options: [.prettyPrinted], error: nil)
stream.close()
}
}
}
}
}
}
}
...
}Finally, the data can be retrieved from the cache if the web service call fails. The data is read from the cache in the background, and the UI is updated by reloading the table view on the main thread:
class UserViewController: UITableViewController {
var users: [[String: Any]]! = nil
var userCacheURL: URL?
let userCacheQueue = OperationQueue()
...
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
if (users == nil) {
// Load the data from the server
AppDelegate.serviceProxy.invoke("GET", path: "/users") { result, error in
if (error == nil) {
self.users = result as? [[String: Any]]
self.tableView.reloadData()
// Write the data to the cache
if (self.userCacheURL != nil) {
self.userCacheQueue.addOperation() {
if let stream = OutputStream(url: self.userCacheURL!, append: false) {
stream.open()
JSONSerialization.writeJSONObject(result!, to: stream, options: [.prettyPrinted], error: nil)
stream.close()
}
}
}
} else if (self.userCacheURL != nil) {
// Read the data from the cache
self.userCacheQueue.addOperation() {
if let stream = InputStream(url: self.userCacheURL!) {
stream.open()
self.users = (try? JSONSerialization.jsonObject(with: stream, options: [])) as? [[String: Any]]
stream.close()
}
// Update the UI
OperationQueue.main.addOperation() {
self.tableView.reloadData()
}
}
}
}
}
}
...
}Now, as long as the application has been able to connect to the server at least once, it can function either online or offline, using the cached response data.
For more ways to simplify iOS app development, please see my projects on GitHub:
