Observer Design Pattern Android Implementation

In this blog, we will learn about implementing the Observer Design Pattern in Android Programming.

If you are using RxJava or RxAndroid, then you might be comfortable with the observer pattern and you can skip the basic introduction part.

Observer Design Pattern

Firstly, what is a “Design Pattern“?

Design patterns are reusable solutions to the most commonly occurring software problems. They can speed up the development process by providing a proven way of resolving frequent issues.

Design Patterns don’t provide you the code but they help you understand the solution to a known problem in theory.

With this in mind, you can write code efficiently.

The Observer pattern is one of the Behavioral Design Patterns, which means it gives us the way to communicate between different classes and objects. This pattern is the best approach if we have a one-to-many relation and we’d like to inform other objects about some changes or actions. For instance, you can notify all the classes accessing a change in the database object so that they can update.

You may know the Observer pattern from RxJava, where it’s implemented in a very extensive way. We have Observable, which is an object we’d like to observe (it may be also called Subject in the Observer pattern) and we can subscribe for observing changes in those object. Every object interested in those changes will be called the Observer. We can have one Subject and many Observers, and these single Observers may know nothing about each other. We can also stop observing changes at any time.

So, we conclude that :

1) Observable(Subject) is an object that actually changes or contains the actual change that happened

2) An observer is our class which is holding an instance of the data(Observable).

Implementation

The basic implementation of the Observer Pattern can be done in two ways in your android application.

Using Broadcast Receivers: For this, you can see the official documents from here. But you will need to pass an intent Filter and send broadcasts for everytime any update occurs
Using Your custom methods: We can see the detailed implementation below.

For implementing the Observer Design Pattern, we need to create two interfaces, one for notifying all the observers that data has changed and one for receiving the update of the actual change.

Along with this a list of what all classes actually need to be notified.

So our Observable(Subject) should actually implement the first interface and our observer should implement the second interface.

Observable Interface code example :

public interface Observerable {
    void addObserver(Observer myObserver);
    void removeObserver(Observer myObserver);
    void notifyObservers(boolean change);// params need to change as per your Observer.
}

public interface Observerable {

void addObserver(Observer myObserver);

void removeObserver(Observer myObserver);

void notifyObservers(boolean change);// params need to change as per your Observer.

}

Observer interface code Example :

public interface Observer {
    void onChange(boolean change); // params need to change as per your use case.
}

public interface Observer {

void onChange(boolean change); // params need to change as per your use case.

}

Now, in all the activities/fragments on which you want to notify the change, you will need to implement the Observable interface.

(I did it in my Base Activity)

And all the possible classes that can change your data you need to implement the Observer interface.

And in the application class or any base class, you will need to maintain a list of all the classes implementing the Observable interface.

(I did it in my application class)

Sample Code

Application class

public class ObserverApplication extends Application {
    private List<Observer> observerList;


    @Override
    public void onCreate() {
        super.onCreate();
        observerList = new ArrayList<>();
// Other Code
    }
    
    public List<Observer> getObserverList() {
         return observerList;
    }

}

public class ObserverApplication extends Application {

private List<Observer> observerList;

@Override

public void onCreate() {

super.onCreate();

observerList = new ArrayList<>();

// Other Code

}

public List<Observer> getObserverList() {

return observerList;

}

BaseActivity

public class BaseActivity extends AppCompatActivity implements Observerable{

     // Other Code as per your requirement
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Other Code as per your requirement
    }

    @Override
    public void notifyObservers(boolean change) {
            for (Observer observer : ((ObserverApplication)BaseActivity.this.getApplication()).getObserverList()){
                observer.onchange(change);
            }
    }

    @Override
    public void addObserver(Observer myObserver) {
        ((ObserverApplication)BaseActivity.this.getApplication()).getObserverList().add(myObserver);
    }

    @Override
    public void removeObserver(Observer myObserver) {
        ((ObserverApplication)BaseActivity.this.getApplication()).getObserverList().remove(myObserver);
    }
}

public class BaseActivity extends AppCompatActivity implements Observerable{

// Other Code as per your requirement

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

// Other Code as per your requirement

}

@Override

public void notifyObservers(boolean change) {

for (Observer observer : ((ObserverApplication)BaseActivity.this.getApplication()).getObserverList()){

observer.onchange(change);

}

@Override

public void addObserver(Observer myObserver) {

((ObserverApplication)BaseActivity.this.getApplication()).getObserverList().add(myObserver);

}

@Override

public void removeObserver(Observer myObserver) {

((ObserverApplication)BaseActivity.this.getApplication()).getObserverList().remove(myObserver);

}

Main Activity

public class MainActivity extends BaseActivity implements Observer{

     // Other Code as per your requirement
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Other Code as per your requirement
    }
    
    @Override
    public void onChange(boolean change) {
      // implement your logic for change over here
      
      notifyObservers(boolean change)// Code to notify all the classes observing this instance
    }
    @Override
    protected void onStart() {
        super.onStart();
        addObserver(this);
    }

    @Override
    protected void onStop() {
        super.onStop();
        removeWishlistObserver(this);
    }
}

public class MainActivity extends BaseActivity implements Observer{

// Other Code as per your requirement

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

// Other Code as per your requirement

}

@Override

public void onChange(boolean change) {

// implement your logic for change over here

notifyObservers(boolean change)// Code to notify all the classes observing this instance

}

@Override

protected void onStart() {

super.onStart();

addObserver(this);

}

@Override

protected void onStop() {

super.onStop();

removeWishlistObserver(this);

}

And with this, you have successfully implemented the Observer Design Pattern in your Android Application.

Keep coding and Keep Sharing 🙂

anchit 8 July 2018

. . .

Observer Design Pattern Android Implementation