Photo by Daniel Lerman on Unsplash

Define a Subscription Mechanism in order to Notify Multiple Objects

Swift — Problems Catalogue #13

Problem Definition:

Consider the following scenario. You have to implement a bird watching app 🦤 how lovely. This app needs to scan birds when they appear (the key word is when) and notify subscribed enthusiasts.

In a nutshell we need an event based system that can transmit information from one entity to multiple entities at the same time.

Problem Solution:

Solution —Observer it’s a behavioral design pattern that allows you to create a subscription mechanism in order to notify multiple objects at the same time.

Real-World Usage:

First, as always, we start with a protocol ✨ that has a notify method. With this method the entity that receives information will receive the notification and do something with it.

Next, let’s create two types of enthusiasts, a duck one 🦆 and a stork one🦩 (yup, that’s a flamingo emoji) and conform them to the Observer protocol. Implementing the notify(scanner: BirdScanner) we can verify the notification’s observedBird state and based on it we can do some business logic.

Figure 1. Observers

Now, let’s handle the entity that “sends” information. Technically it sends itself.

The BirdScanner has an array of observers and if the notify() method is called it goes through them and calls every observer’s notify method and passes itself and exposing the observedBird variable.

When talking about the observer design pattern, the BirdScanner class is called usually a Subject.

Also, we need two additional important methods, the subscribe and the unsubscribe method that adds and removes observers from our array.

Figure 2. Subject

Finally, let’s put everything together in our BirdWatchingApp and use our subscription mechanism to it’s fullest.

Figure 3. Bird Watching App

From this point on, the sky is the limit 🚀 well…almost.

Of course, this design pattern has its limitations but used in moderation, it’s a great tool in our development toolbox.

This is the next article in the Swift Problems Catalogue series in which I’ll tackle general software development problems. The aim is to have a quick reference guide that can be easily accessed when having a design/algorithm dillemma.

Let me know what you think and don’t be shy to share where and when this pattern simplified your coding experience 🎶