Waiting until a certain task completely finish to execute another task - swift

Question

I'm trying to retrieve some encryption messages from Firebase Realtime Database, decrypt them, and display them in the CollectionView. The decrypting process is successful, but I have faced a problem about multithreading that: The order of the fetched-decrypted messages added to the Messages array is wrong, so they are not displayed in the CollectionView with the correct order, the order of displaying message in CollectionView varies during each run. I thought this problem happens because the time needed to finish decrypting process of each encrypted message is different, some encrypted messages need more time to decrypt, and some encrypted messages finish decrypting before others, so the order that they are added to the Messages array is no longer correct. The workflow that I expect that:
Making fetch request to the messages node on Firebase Database
With each fetched message:
3.1. Decrypt it
3.2. Append it to the Messages array
3.3. Reload the CollectionView to update UI
But I don't know how to use GCD to achieve that correctly, the showing messages is not in the correct order because the concurrency problem. But, I found a solution that if I try to place a sleep(1) command to my code, the code run correctly, but it's too slow because of sleeping command. I tried many ways, but it doesn't seem right, except for using sleep(1) command. Please help me to do this properly, thank you so much!. Here is my code:
func observeMessage(){
self.eThree = VirgilHelper.sharedVirgilHelper.eThreeToUse!
// Get current user's UID
guard let uid = FIRAuth.auth()?.currentUser?.uid , let toId = self.user?.id else {
return;
}
let userMessagesRef = FIRDatabase.database().reference().child("user-messages").child(uid).child(toId);
userMessagesRef.observe(.childAdded, with: { (snapshot) in
let messageId = snapshot.key;
let messagesRef = FIRDatabase.database().reference().child("messages").child(messageId);
// Observe the entire value of that node
messagesRef.observeSingleEvent(of: .value, with: { (snapshot) in
if let dictionary = snapshot.value as? [String:AnyObject] {
//sleep(1) // The working sleep command, but it's too slow
let message = Message(dictionary: dictionary)
if let fromUID = message.fromId, let toUID = message.toId, let cipherText = message.text {
self.eThree!.lookupPublicKeys(of: [fromUID], completion: { (lookupResult, error) in
if error != nil {
print("Error when looking up the Public Key of UID \(fromUID), \(String(describing: error))")
}
if let lookupResult = lookupResult {
message.text = try! self.eThree!.decrypt(text: cipherText, from: lookupResult[fromUID]!)
print("text: \(message.text)")
// The concurency prolem happens at here
self.messages.append(message);
// Go back to main thread to update UI
DispatchQueue.main.async {
// The concurency prolem happens at here, UI doesn't display with correct order of fetched-decrypted messages
self.collectionView?.reloadData()
let indexPath = IndexPath(item: self.messages.count-1, section: 0)
self.collectionView?.scrollToItem(at: indexPath, at: .bottom, animated: true);
}
}
})
}
}
}, withCancel: nil)
}, withCancel: nil)
}

Answer 1

In Swift, to wait for another task to be done before continue on with other task, you can use DispatchQueue.group().
let group = DispatchGroup()
group.enter()
DispatchQueue.main.async {
print("1")
group.leave()
}
group.enter()
DispatchQueue.main.async {
print("2")
group.leave()
}
group.enter()
DispatchQueue.main.async {
print("3")
group.leave()
}
group.notify(queue: .main) {
print("Done")
}
So the way you use it:
Initialize group
Enter the group by: group.enter(), before you start task
Put: group.leave(), after each task
Pass closure to group.notify. It will be executed when group task is empty.
NOTE:
A number of .enter() needs to match with .leave()