View Javadoc
   package br.ufsc.tlm.j2me.logging;
   
   import java.io.ByteArrayOutputStream;
   import java.io.DataOutputStream;
   import java.io.IOException;
   import java.util.Hashtable;
   
   import javax.microedition.rms.RecordStore;
   import javax.microedition.rms.RecordStoreException;
  
  /***
   * Created on Aug 26, 2003
   * @author Eric Giguere
   * Implemented by Thiago Lećo Moreira <thiago.leao.moreira@terra.com.br> from the article "A Simple MIDP Logging Facility" 
   * avaiable in http://wireless.java.sun.com/midp/ttips/logging/  
   */
  public class Logger {
  
  	//Static data
  	private static Hashtable loggers = new Hashtable();
  	private static boolean logToRS = true;
  	private static boolean logToStdout = true;
  	private static Logger root = new Logger("");
  	private static RecordStore rs;
  
  	static {
  		// Initialize the root level
  		loggers.put("", root);
  		root.setParent(null);
  		root.setLevel(Level.INFO);
  	}
  
  	//Instance data
  	private Level level;
  	private String name;
  	private Logger parent;
  	private int version;
  
  	/***
  	 *  Call to close the log.
  	 */
  	public static void closeLog() {
  		try {
  			if (rs != null) {
  				rs.closeRecordStore();
  			}
  		} catch (RecordStoreException e) {
  		}
  		rs = null;
  	}
  
  	/***
  	 *  Find the logger registered with a specific name.
  	 */
  	public static synchronized Logger getLogger(String name) {
  		Logger logger = (Logger) loggers.get(name);
  		if (logger == null) {
  			logger = new Logger(name);
  			loggers.put(name, logger);
  		}
  		return logger;
  	}
  
  	/***
  	 * Open the log file if not already open.
  	 */
  	private static RecordStore openLog() throws RecordStoreException {
  		if (rs == null) {
  			rs = RecordStore.openRecordStore("log", true);
  		}
  		return rs;
  	}
  
  	/***
  	 * Whether or not to log to the record store.
  	 */
  	public static void setLogToRS(boolean log) {
  		Logger.logToRS = log;
  	}
  
  	/***
  	 * Whether or not to log to System.out.
  	 */
  	public static void setLogToStdout(boolean log) {
  		Logger.logToStdout = log;
  	}
  
  	/***
  	 *  Create a new instance of Logger
  	 */
  	private Logger(String name) {
  		this.name = name;
  	}
  
  	/***
  	 *  Call to clear the log, which must be closed.
  	 */
  	public synchronized void clearLog() throws RecordStoreException {
  		RecordStore.deleteRecordStore("log");
 	}
 
 	/***
 	 *  Finds the logger's parent by parsing the name into parts separated by '.'
 	 */
 	private Logger findParent(String name) {
 		if (name == null || name.length() == 0) {
 			return null;
 		}
 		Logger parent;
 		synchronized (loggers) {
 			while (true) {
 				int pos = name.lastIndexOf('.');
 				if (pos < 0) {
 					parent = root;
 					break;
 				}
 
 				String pname = name.substring(0, pos);
 				parent = (Logger) loggers.get(pname);
 				if (parent != null) {
 					break;
 				}
 				name = pname;
 			}
 		}
 
 		return parent;
 	}
 
 	/***
 	 *  Log a message with the FINE level.
 	 */
 	public void fine(String msg) {
 		log(Level.FINE, msg);
 	}
 
 	/***
 	 *  Get this logger's level, which may be null.
 	 */
 	public Level getLevel() {
 		return level;
 	}
 
 	/***
 	 *  Return the logger's name.
 	 */
 	public String getName() {
 		return name;
 	}
 
 	/***
 	 * Return the logger's parent. The parent is reset if other loggers were created, in
 	 * case children are created after their parents.  
 	 */
 	public Logger getParent() {
 		if (loggers.size() != version) {
 			setParent(findParent(name));
 		}
 		return parent;
 	}
 
 	/***
 	 *  Log a message with the INFO level.
 	 */
 	public void info(String msg) {
 		log(Level.INFO, msg);
 	}
 
 	/***
 	 * Test whether the given level is loggable according to this Logger.
 	 */
 	public boolean isLoggable(Level test) {
 		if (test == null) {
 			return false;
 		}
 		Logger curr = this;
 		while (curr != null) {
 			Level actual = curr.getLevel();
 			if (actual != null) {
 				if (actual == Level.OFF) {
 					return false;
 				}
 				return (test.intValue() >= actual.intValue());
 			}
 			curr = curr.getParent();
 		}
 		return false;
 	}
 
 	/***
 	 * Log a message using the given level.
 	 */
 	public void log(Level level, String msg) {
 		log(level, msg, null);
 	}
 
 	/***
 	 * Log a message using the given level including optional exception information.
 	 */
 	public void log(Level level, String msg, Throwable e) {
 		if (level == null) {
 			level = Level.FINE;
 		}
 		if (!isLoggable(level)) {
 			return;
 		}
 		long time = System.currentTimeMillis();
 		String tname = Thread.currentThread().toString();
 
 		if (Logger.logToStdout) {
 			String tmp = msg;
 			if (e != null) {
 				tmp = msg + " " + e;
 			}
 			System.out.println(time + " " + tname + " " + level + " " + tmp);
 		}
 
 		if (!Logger.logToRS) {
 			return;
 		}
 
 		// Prepare the data
 		ByteArrayOutputStream bout = new ByteArrayOutputStream();
 		DataOutputStream dout = new DataOutputStream(bout);
 		try {
 			dout.writeInt(level.intValue());
 			dout.writeLong(System.currentTimeMillis());
 			dout.writeUTF(Thread.currentThread().toString());
 			dout.writeUTF(msg != null ? msg : "");
 			dout.writeUTF(e != null ? e.toString() : "");
 			dout.flush();
 		} catch (IOException ex) {
 		}
 		byte[] data = bout.toByteArray();
 
 		// Write it out
 		synchronized (this) {
 			RecordStore rs = null;
 			boolean closeIt = (rs == null);
 
 			try {
 				rs = openLog();
 				rs.addRecord(data, 0, data.length);
 			} catch (RecordStoreException ex) {
 			} finally {
 				if (closeIt) {
 					closeLog();
 				}
 			}
 		}
 	}
 
 	/***
 	 * Sets the logger's level. May be null.
 	 */
 	public void setLevel(Level level) {
 		this.level = level;
 	}
 
 	/***
 	 * Sets the logger's parent.
 	 */
 	public void setParent(Logger parent) {
 		this.parent = parent;
 		version = loggers.size();
 	}
 
 	/***
 	 *  Log a message with the SEVERE level.
 	 */
 	public void severe(String msg) {
 		log(Level.SEVERE, msg);
 	}
 
 	/***
 	 *  Log a message with the WARNING level.
 	 */
 	public void warning(String msg) {
 		log(Level.WARNING, msg);
 	}
 
 }