Nested callback strong reference cycle - ios

Question

#IBAction func sendSweet(sender: UIBarButtonItem) {
var inputTextField: UITextField?
let alert = UIAlertController(title: "New sweet", message: "Enter a sweet", preferredStyle: .alert)
alert.addTextField { (textField: UITextField) in
textField.placeholder = "Your sweet"
inputTextField = textField
}
let sendAction = UIAlertAction(title: "Send", style: .default, handler: {
[weak self] (alertAction: UIAlertAction) in
guard let strongSelf = self else { return }
if inputTextField?.text != "" {
let newSweet = CKRecord(recordType: "Sweet")
newSweet["content"] = inputTextField?.text as CKRecordValue?
let publicData = CKContainer.default().publicCloudDatabase
publicData.save(newSweet, completionHandler: {
(record: CKRecord?, error: Error?) in
if error == nil {
// we want ui code to dispatch asychronously in main thread
DispatchQueue.main.async {
strongSelf.tableView.beginUpdates()
strongSelf.sweets.insert(newSweet, at: 0)
let indexPath = IndexPath(row: 0, section: 0)
strongSelf.tableView.insertRows(at: [indexPath], with: .top)
strongSelf.tableView.endUpdates()
}
} else {
if let error = error {
print(error.localizedDescription)
return
}
}
})
}
})
alert.addAction(sendAction)
alert.addAction(UIAlertAction(title: "Cancel", style: .cancel, handler: nil))
present(alert, animated: true, completion: nil)
}
I have this callback hell, I want to know
Does the [weak self] & guard let strongSelf at very top of the callback hell prevent the strong reference cycle all out through the GCD's async callback. I read some other post at here, also one from a book, that said if the object I refer inside a callback can deinit successfully, it means a good sign for not having strong reference cycle, is it still true?
How to prevent this kind of callback hell, can you lead me to some reading material or topic I have missed? anything like javascript's promise chaining syntax?

Answer 1

As far as I can see there is no retain cycle and thus there is no need to weakify self. You certainly can do it in every block to be defensive.
There is no retain cycle because the instance (self) does not have reference to any of the closures. Especially to sendAction, as sendAction is declared inside of the sendSweet function.
class MyView: UIView {
let str = "some variable to have somsthing to use self with"
func foo() {
let ba = {
// no problem. The instance of MyView (self) does not hold a (strong) reference to ba
self.str.trimmingCharacters(in: CharacterSet.alphanumerics)
}
ba()
}
}
If you would move let sendAction = ... outside of the function as a property of the instance, you would have a reference cycle though. In this case the instance (self) would have a strong refrence to sendAction and the sendAction closure would have a strong reference to the instance (self):
self <-> { self. ...} aka sendAction.
class MyView: UIView {
let str = "asd"
// Problem.
// The instance of MyView (self) does hold a (strong) reference to ba ...
let ba: () -> Void
override init(frame: CGRect) {
super.init(frame: frame)
ba = {
// ... while ba holds a strong reference to the instance (self)
self.str.trimmingCharacters(in: CharacterSet.alphanumerics)
}
}
func foo() {
ba()
}
}
In this case you have to break the cycle by weakifying self within the closure, like you did.
How to prevent this kind of callback hell, can you lead me to some reading material
Checkout DispatchGroups.
(Apple Documentation)

Answer 2

Found a pretty neat solution to my problem #2
https://github.com/duemunk/Async
Example snippet:
Async.userInitiated {
return 10
}.background {
return "Score: \($0)"
}.main {
label.text = $0
}