How do I reload my view controller so that my JSON updates? - ios

Question

I am loading some JSON data into a UITableView. Each cell has a delete button and when this button is pressed the object is successfully deleted from the server. However, the page doesn't update to reflect this change. I want the table view to reload but without the deleted object. I have tried calling viewDidLoad() and viewDidAppear() as well as several other tricks I've found online. Currently, I am using a workaround that sends the user back to the home page. From there when you click on the page with the table view, it has updated to reflect the changes. However, I cannot seem to make this happen without leaving the view controller and coming back to it. I know that the API​ calls are working correctly, the page just isn't "refreshing". What should I try to make this work?
Thank you very much! My code for the entire class is below (I've added a couple comments to point out the places I am having problems with)
import UIKit
class Garage: UIViewController, UITableViewDelegate, UITableViewDataSource {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return self.vehicles.count
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: "cell1", for: indexPath) as UITableViewCell
cell.textLabel?.text = vehicles[indexPath.row].year + " " + vehicles[indexPath.row].make + " " + vehicles[indexPath.row].model
let button = UIButton(type: .custom)
button.backgroundColor = UIColor.green
button.sizeToFit()
cell.accessoryType = .detailButton
return cell
}
func tableView(_ tableView: UITableView, accessoryButtonTappedForRowWith indexPath: IndexPath) {
print("tapped")
let alert = UIAlertController(title: "Would you like to delete this vehicle?", message: "This action cannot be undone.", preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "No", style: .cancel, handler: nil))
self.present(alert, animated: true)
alert.addAction(UIAlertAction(title: "Yes", style: .default, handler: { action in
print("DELETED")
//
//THIS IS WHERE THE DELETE ACTION IS CALLED
//
var id = self.vehicles[indexPath.row].id
print("got here 1")
let api = "https://api.myapi.com/"
let parameters: [String: String] = ["id": id]
guard let url = URL(string: api + id) else { return }
var request = URLRequest(url: url)
let headers: [String: String] = [
"Content-Type": "application/json"
]
request.allHTTPHeaderFields = headers
request.httpMethod = "DELETE"
let requestBody = try? JSONSerialization.data(withJSONObject: parameters, options: [])
if let requestBody = requestBody {
request.httpBody = requestBody
}
//
//THIS IS WHERE I TRY TO RELOAD THE PAGE
//
print("reloading...")
self.viewDidLoad()
self.viewWillAppear(true)
URLSession.shared.dataTask(with: request) { (data, response, error) in
// print("Data, response, error", data, response, error)
if let data = data {
let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] ?? [:]
print("json", json)
}
DispatchQueue.main.async {
self.tableVehicles.reloadData()
self.view.setNeedsLayout()
self.performSegue(withIdentifier: "GarageToHome", sender: self)
}
}.resume()
//
//THIS IS MY CURRENT WORK-AROUND
//
self.performSegue(withIdentifier: "GarageToHome", sender: self)
}))
}
#IBOutlet weak var label1: UILabel!
struct Vehicle {
var make: String
var model: String
var year: String
var Trim: String
var id: String
init(_ dictionary: [String: Any]) {
self.make = dictionary["make"] as? String ?? ""
self.model = dictionary["model"] as? String ?? ""
self.year = dictionary["year"] as? String ?? ""
self.Trim = dictionary["trim"] as? String ?? ""
self.id = dictionary["id"] as? String ?? ""
}
}
var vehicles = [Vehicle]()
#IBOutlet weak var tableVehicles: UITableView!
override func viewDidLoad() {
super.viewDidLoad()
// print("login name:", username)
self.tableVehicles.delegate = self
self.tableVehicles.dataSource = self
self.tableVehicles.reloadData()
}
override func viewWillAppear(_ animated: Bool) {
//vehicles = [Vehicle]()
let defaults = UserDefaults.standard
defaults.synchronize()
let token = UserDefaults.standard.string(forKey: "token")
let isSignedIn = UserDefaults.standard.bool(forKey: "isUserLoggedIn")
var username = UserDefaults.standard.string(forKey: "loginName")
defaults.synchronize()
DispatchQueue.main.async {
self.label1.text = "Welcome, " + username! + "!"
defaults.synchronize()
}
guard let url = URL(string: "https://api.myapi.com") else {return}
let task = URLSession.shared.dataTask(with: url) { (data, response, error) in
guard let dataResponse = data,
error == nil else {
print(error?.localizedDescription ?? "Response Error")
return }
do{
let jsonResponse = try JSONSerialization.jsonObject(with:
dataResponse, options: [])
//print(jsonResponse) //Response result
guard let jsonArray = jsonResponse as? [[String: Any]] else {
return
}
for dic in jsonArray{
self.vehicles.append(Vehicle(dic))
}
print(self.vehicles)
DispatchQueue.main.async {
self.tableVehicles.delegate = self
self.tableVehicles.dataSource = self
self.tableVehicles.reloadData()
}
} catch let parsingError {
print("Error", parsingError)
}
}
task.resume()
}
}

Answer 1

First of all, never ever call delegate methods containing will, did and should yourself. Don't do that. Those methods are exclusively called by the framework.
There is a quite easy solution. You know the index path of the deleted row so if the data task succeeds remove the item from the data source array and delete the row in the table view. Reloading the entire table view and updating the data source array from the downloaded data is not necessary.
Anyway you need a clear indicator that the server operation was successful, I don't know if if let data = data in the dataTask is sufficient.
//THIS IS WHERE I TRY TO RELOAD THE PAGE
//
print("reloading...")
URLSession.shared.dataTask(with: request) { (data, response, error) in
// print("Data, response, error", data, response, error)
if let data = data {
let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] ?? [:]
print("json", json)
DispatchQueue.main.async {
self.vehicles.remove(at: indexPath.row)
tableView.deleteRows(at: [indexPath], with: .fade)
self.performSegue(withIdentifier: "GarageToHome", sender: self)
}
}
}.resume()

Answer 2

While you are calling both -viewDidLoad and -viewWillAppear(which are reloading your table view and performing your API request to fetch your data and populate your model respectively) one reason you might not be seeing your underlying data model appear to update is that you are calling both before you actually try to send the deletion request to your API endpoint. If you move your call to -viewWillAppear into the completion block of your delete request then that will ensure that your request to fetch the updated data from your API occurs after the deletion is finished.
That is the very least you could do to potentially get this working like you expect, however I would strongly recommend taking a little time to factor out your business and networking logic. You should not manually be calling -viewDidLoad or -viewWillAppear yourself. These are UIViewController lifecycle methods that are called by UIKit for you during the lifecycle of your view controller. Instead I'd recommend (at the very least) factoring out some methods or methods into other classes that handle things like fetching your data model from the server or deleting specific records. Then, you can call those methods from your table view delegate or UIAlertAction in a more re-usable and isolated manner without worrying about any unintended side effects of calling your UIViewController lifecycle methods just to fetch some data again.
So, while I really don't recommend you end up with this as your final code, instead of this:
//THIS IS WHERE I TRY TO RELOAD THE PAGE
//
print("reloading...")
self.viewDidLoad()
self.viewWillAppear(true)
URLSession.shared.dataTask(with: request) { (data, response, error) in
You could do this:
URLSession.shared.dataTask(with: request) { (data, response, error) in
//THIS IS WHERE I TRY TO RELOAD THE PAGE
//
print("reloading...")
self.viewDidLoad()
self.viewWillAppear(true)
Again, I highly recommend, at the very least, extracting your fetch and delete API logic.
You also have several options for how you go about performing the delete action and making it appear to the user that the record was deleted.
As described above, the minimal changes required to what you have would just to ensure that your updated data model is only fetched once the deletion request succeeds.
Alternatively you can optimistically make it appear that your delete request has succeeded by updating your backing data model locally and either deleting the affected row or reloading your table.
Since the former approach is subject to connectivity and networking latency issues it may appear really laggy to the user when they try to delete a record and you lose the ability to take advantage of UITableView animations that make it clear that a row has been deleted.
The latter approach will appear more responsive to the user. For this approach you would need to remove deleted object from your array where you are currently calling -viewDidLoad and -viewWillAppear: and then remove the corresponding row. Something like:
self.vehicles.removeAt(indexPath.row)
tableView.deleteRows(at: [indexPath], with: .automatic)
You have a choice of animation types.
One challenge of optimistically deleting the record and row locally in your app is that if the API request fails for some reason then your user experience could appear inconsistent the next time your data model is fetched - it'll appear as if the record was not deleted (which is actually the case). So depending on the importance of consistency and how much error handling you care to do then you'll need to reconcile any errors that come about as part of your deletion request. Here again, you have many options. You can try the delete again behind the scenes, you could alert your user and then add the row back so they can try again, or just do nothing.