Observers and Observables in Android

-

Within the android framework there’s a somewhat vague usage of the MVC pattern. We can see it happening with Activities, Adapters of all kinds and in fragments as well. But there’s a hidden gem within the java.util package which can be used very easily as the grounds for a publisher subscriber needed scenarios : java.util.Observer, java.util.Observable.

The approach is quite easy to grasp and is identical to the usage in other platforms and programming languages. The Observer announces that he wishes to subscribe to events and the publisher holds a list of subscribers which he can notify on data being changed with a simple callback.

In this very simple example, there’s an activity which contains a TextView which is updated by values. The Activity implements the Observer interface, which forces it to implement the update(Observable observable, Object data){} which will be invoked by the publisher, the parameters are the reference to the publisher and the data that is being published.

On the other hand there’s an entity which is the publisher, which has the responsibility to do some work and notify on data changes to it’s subscribers.

The entity needs to extends the Observable class, and that’s it pretty much. once it need to publish an update to it’s subscribers it simply sets its “changed” flag with setChanged(), followed by the notifyObservers(data) call.

Quick dirty example: (the example is really a forced one, but you will get the hang of it)

package com.shmoontz.observertutorial;

import java.util.Observable;
import java.util.Observer;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

public class MainActivity extends Activity implements Observer {

    private Model mModel;
    private TextView mTextView;

    @SuppressWarnings("unchecked")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.clicks_counter);

        mModel = new Model();
        mModel.addObserver(this);
        mModel.start();

    }

    @Override
    public void update(Observable observable, Object data) {
        mTextView.setText(String.valueOf(data));
    }
   
   

    @SuppressWarnings("rawtypes")
    public class Model extends Observable {
        private static final int N = 10;
        private final String TAG = Model.class.getSimpleName();
        int mCounter;

        public void start() {
            for (int i = 1; i < N; i++) {
                mCounter += i;
                Log.d(TAG, "observers count=" + countObservers()
                        + ", now notifying the observers that current sum is "
                        + mCounter);
                setChanged();
                notifyObservers(mCounter);

            }
        }

        public int getCurrentData() {
            return mCounter;
        }
    }

}

Comments

Post a Comment

Popular posts from this blog

Spinner VS AutoCompleteTextView

-
Image
       We’ve all been in a situation where we needed to show a list of some sort, a list which should be triggered by a user interaction (click, tap, etc..) A list is simple enough, probably even a spinner if we don’t want to spend that much screen real-estate on showing a list which the user clicks once and probably doesn’t need to see it after that. A spinner can be a real bug once there are too much entries for the user to choose from, how much is too much? that’s a good question – probably it differs from user to user, and probably this will have some performance issues with areal large number of entries, you cannot scroll forever to find what you’re looking for. A simple solutions for the problems mentioned above is an AutoCompleteTextView. it’s a control which is basically a combination of a TextView, EditText, and a Spinner all wrapped up in a single easy to use and configurable control. let’s see how it’s done:   first, in the layout file, c...
Read more

Utilizing Http response cache

-
     A typical mobile application will probably consume some resources from a web server using http requests. This repeated task has some drawbacks: Bandwidth has a cost, polling the same data over and over again results in a waste of user’s quota. the responsiveness and user experience is compromised once the user keeps waiting for data. If the requested data hasn’t changed on the server, then there’s no reason for us to fetch it. Of course, local caching of data is a must, but we also need to be able to refresh the data if it has changed on the server. A simple solution which comes out of the box for API 4+ is http response caching. Http response caching is a mechanism which enables us as developers to save a footprint of the response utilizing the abilities of the Http protocol. Basically, is holds a simple cache of the response which can be defined and enabled in code, and it prevents from fetching unchanged data from the server which was already fetched a...
Read more

ORM for android

-
     ORM – Object relational mapping has been around for quite some time now. Basically it’s a piece of software (regardless of targeted platform), which simplifies the connection between objects (as in OOP) and data in database (mostly used is tables based relational database), and it exists in order to help simplify bridging the gap between the two in our development process.     Microsoft's Entity framework is a great example for a robust easy to use framework which allows creating and querying the database from an object’s point of view with classic object oriented programming paradigms while maintaining all DB construction’s needs such as relationships between objects (tables) such as one to many or many to many including all the indexing, optimization etc..      In android, we have SQLite as a database platform, from simple to advanced application, it’s likely to assume that we’ll need some relational database to store and r...
Read more