观察者模式用法

1、创建观察者IObserver接口

import android.os.Message;

public interface IObserver {
   abstract public void listen(Message inMessage);
}

2、创建被观察者ISubject接口

import android.os.Message;

public interface ISubject {
   public final static int FLAG_RUN_SYNC = 0;
   public final static int FLAG_RUN_MAIN_THREAD = 1;

   public boolean addObserver(IObserver inObserver);

   public boolean removeObserver(IObserver inObserver);

   public void notify(Message inMessage, int... flag);
}

3、创建绑定ObserverAdapter

import android.os.Handler;
import android.os.Looper;
import android.os.Message;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

public class ObserverAdapter {
   private HashMap<ISubject, ArrayList<IObserver>> mSubjectObserverMap;

   @Override
   protected void finalize() throws Throwable {
      super.finalize();
      mHandler.removeMessages(0);
   }

   private class ObserverHandler extends Handler {
      public ObserverHandler(Looper looper) {
         super(looper);
      }

      public void handleMessage(Message msg) {
         Object[] objects = (Object[]) msg.obj;
         IObserver observer = (IObserver) objects[0];
         Message message = (Message) objects[1];
         observer.listen(message);
      }
   }

   private static class SafeInstanceHolder {
      public static ObserverAdapter sInstance = new ObserverAdapter();
   }

   public static synchronized ObserverAdapter getInstance() {
      return SafeInstanceHolder.sInstance;
   }

   private ObserverHandler mHandler = null;

   private ObserverAdapter() {
      mSubjectObserverMap = new HashMap<ISubject, ArrayList<IObserver>>();
      mHandler = new ObserverHandler(Looper.getMainLooper());
   }

   public synchronized boolean register(ISubject inSubject,
         IObserver inObserver) {
      boolean ret = false;
      if (mSubjectObserverMap.containsKey(inSubject)) {
         ArrayList<IObserver> list = mSubjectObserverMap.get(inSubject);
         if (!list.contains(inObserver)) {
            list.add(inObserver);
            ret = true;
         }
      } else {
         ArrayList<IObserver> list = new ArrayList<IObserver>();
         list.add(inObserver);
         mSubjectObserverMap.put(inSubject, list);
         ret = true;
      }
      return ret;
   }

   public synchronized boolean unregister(ISubject inSubject,
         IObserver inObserver) {
      if (mSubjectObserverMap.containsKey(inSubject)) {
         ArrayList<IObserver> list = mSubjectObserverMap.get(inSubject);
         list.remove(inObserver);
         if (list.size() <= 0) {
            mSubjectObserverMap.remove(inSubject);
         }
      }
      return true;
   }

   public synchronized void clear() {
      // should avoid avoid ()null pointer issue.
      for (Iterator<ISubject> it = mSubjectObserverMap.keySet().iterator(); it
            .hasNext();) {
         ISubject subject = (ISubject) it.next();
         ArrayList<IObserver> list = mSubjectObserverMap.get(subject);
         if (list == null)
            continue;
         list.clear();
      }
      mSubjectObserverMap.clear();
   }

   public synchronized void clear(Object inSubject) {
      if (mSubjectObserverMap.containsKey(inSubject)) {
         ArrayList<IObserver> list = mSubjectObserverMap.get(inSubject);
         list.clear();
         mSubjectObserverMap.remove(inSubject);
      }
   }

   public void notify(Message inMessage, int... flag) {
      // should avoid null pointer issue.
      for (Iterator<ISubject> it = mSubjectObserverMap.keySet().iterator(); it
            .hasNext();) {
         ISubject subject = (ISubject) it.next();
         notify(subject, inMessage, flag);
      }
   }

   public void notify(ISubject inSubject, Message inMessage, int... flag) {
      ArrayList<IObserver> list = mSubjectObserverMap.get(inSubject);
      if (list == null)
         return;
      for (Iterator<IObserver> it = list.iterator(); it.hasNext();) {
         IObserver observer = (IObserver) it.next();

         if (observer != null) {
            boolean asyncMode = false;
            if (flag.length > 0 && flag[0] == ISubject.FLAG_RUN_MAIN_THREAD) {
               asyncMode = true;
            }
            if (asyncMode) {
               Object[] objects = new Object[] { observer, inMessage };
               mHandler.sendMessage(mHandler.obtainMessage(0, objects));
            } else {
               observer.listen(inMessage);
            }
         }
      }
   }

   public void notify(IObserver observer, Message inMessage, int... flag) {
      boolean asyncMode = false;
      if (flag.length > 0 && flag[0] == ISubject.FLAG_RUN_MAIN_THREAD) {
         asyncMode = true;
      }
      if (asyncMode) {
         Object[] objects = new Object[] { observer, inMessage };
         mHandler.sendMessage(mHandler.obtainMessage(0, objects));
      } else {
         observer.listen(inMessage);
      }
   }
}

4、被观察者类实现被观察接口

import android.os.Message;

public abstract class BaseSubject implements ISubject {

   /*
    * (non-Javadoc)
    * 
    * @see
    * common.utils.observer.ISubject#attach(common.utils.observer.IObserver)
    */
   @Override
   public boolean addObserver(IObserver inObserver) {
      return ObserverAdapter.getInstance().register(this, inObserver);
   }

   /*
    * (non-Javadoc)
    * 
    * @see
    * common.utils.observer.ISubject#detach(common.utils.observer.IObserver)
    */
   @Override
   public boolean removeObserver(IObserver inObserver) {
      return ObserverAdapter.getInstance().unregister(this, inObserver);
   }

   /*
    * (non-Javadoc)
    * 
    * @see common.utils.observer.ISubject#notify(android.os.Message, int)
    */
   @Override
   public void notify(Message inMessage, int... flag) {
      ObserverAdapter.getInstance().notify(this, inMessage, flag);
   }

}

5、观察者类实现观察者接口

import com.hsae.d531mc.systemsetting.observer.IObserver;

public class GeneralPresenter implements IObserver { 

    @Override
    public void listen(Message inMessage) {//监听
        switch (inMessage.what) {
            case GeneralUtil.GENERAL_INIT:
               //TODO
            case GeneralUtil.LANGUAGE_SET:
                //TODO
            case GeneralUtil.STANDBY_SCREEN_SET:
                //TODO
            default:
                break;
        }
    }
}

6、调用

public class GeneralView extends BaseSubject{

    public void initData() {
        sendMessage(GeneralUtil.GENERAL_INIT, null);
    }

    private void sendMessage(int what, Object obj) {
        Message msg = Message.obtain();
        msg.what = what;
        msg.obj = obj;
        notify(msg, FLAG_RUN_SYNC);
    }

}