An Implementation of Android Message Framework

IMessage.java

public interface IMessage {

}

IMessageListener.java

 

public abstract class IMessageListener<T extends IMessage> {
	
	@SuppressWarnings("unchecked")
	void onReceive(IMessage message) {
		if(belongTome(message) == true) {
			onMessage((T)message);
			String name = Thread.currentThread().getName();
			Log.d("IMessageListener", "Thread name : " + name);
		}
	}
	
	protected abstract void onMessage(T message);
	
	protected abstract boolean belongTome(IMessage message);
}

MessageCenter.java

 

public class MessageCenter {

	private static class InstanceHolder {
		private static MessageCenter mInstance = new MessageCenter();
	}

	public static MessageCenter getInstance() {
		return InstanceHolder.mInstance;
	}

	private MessageCenter() {
		(new BackgroundThread()).start();
	}

	private List<IMessageListener<? extends IMessage>> mListeners = new ArrayList<IMessageListener<? extends IMessage>>();

	public void registListener(IMessageListener<? extends IMessage> listener) {
		synchronized (getInstance()) {
			if (listener != null && !mListeners.contains(listener)) {
				mListeners.add(listener);
				Log.d("MessageCenter", "registListener listeners count: " + mListeners.size());
			}
		}
	}

	public void unRegistListener(IMessageListener<? extends IMessage> listener) {
		synchronized (getInstance()) {
			mListeners.remove(listener);
			Log.d("MessageCenter", "unRegistListener listeners count: " + mListeners.size());
		}
	}

	public void sendMesssageToMainThread(IMessage msg) {
		android.os.Message message = mMainHandler.obtainMessage();
		message.obj = msg;
		mMainHandler.sendMessage(message);
	}

	public void sendMessageToBackgroundThread(IMessage msg) {
		android.os.Message message = mBackgroundHandler.obtainMessage();
		message.obj = msg;
		mBackgroundHandler.sendMessage(message);
	}

	private synchronized static void fireListeners(IMessage msg) {
		synchronized (getInstance()) {
			for (IMessageListener<? extends IMessage> listener : getInstance().mListeners) {
				listener.onReceive(msg);
			}
			Log.d("MessageCenter", "fireListeners listeners count: " + getInstance().mListeners.size());
			String name = Thread.currentThread().getName();
			Log.d("MessageCenter", "fireListeners Thread name : " + name);
		}
	}

	private static Handler mMainHandler = new Handler() {
		public void handleMessage(android.os.Message message) {
			super.handleMessage(message);
			Object obj = message.obj;
			if (obj instanceof IMessage) {
				IMessage msg = (IMessage) obj;
				fireListeners(msg);
			}
		}
	};

	private static BackgroundHandler mBackgroundHandler = null;

	private static class BackgroundThread extends Thread {
		@Override
		public void run() {
			super.run();
			Looper.prepare();
			mBackgroundHandler = new BackgroundHandler(Looper.myLooper());
			Looper.loop();
		}
	}

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

		@Override
		public void handleMessage(Message message) {
			super.handleMessage(message);
			Object obj = message.obj;
			if (obj instanceof IMessage) {
				IMessage msg = (IMessage) obj;
				fireListeners(msg);
			}
		}
	};
}