package com.naviexpert.util;
/**
* J2ME log class
*/
public class Log {
    /** A monitor used for thread synchronisation. */
    private final static Object monitor = new Object();
    /** Class {@link Log} used for logging */
    public static Log logger = null;
    /**
     * logger class time initialisation.
     */
    public static long loggerInitializationTime = System.currentTimeMillis();
    /**
     * Static initialisation block creating logger class.
     * Change on subclass now causes exchange logger way into
     * implemented by subclass.
     */
    static {
        try {
            logger = new Log();
        } catch (Throwable t) {
            logger = new Log();
        }
    }
    /** Login flag */
    public static final boolean LOGGING_ON = true;
    /** flag switching on login synchronisation */
    public static final boolean SYNCHRONIZED_LOG = true;
    /* Definition of login level (filter). */
    public final static int DEBUG = 0;
    public final static int INFO = 1;
    public final static int WARN = 2;
    public final static int ERROR = 3;
    /** message filter level */
    private static int filterAt = DEBUG;
    /** Static string table related to login level. */
    protected final static String[] levels = new String[] { "[debug] ", "[info] ", "[warn] ", "[error] " };
    /** Classical development of this class is forbidden */
    protected Log() {
    }
   /**
     * Sending message bundled with thread.
     *
     * @param level message level
     * @param message message content
     * @param exception Thread bundled with message or
     *        <code>null</code>.
     */
    public static void log(int level, String message, Throwable exception) {
        if (LOGGING_ON) {
            if (level < filterAt) return;
            if (SYNCHRONIZED_LOG) {
                synchronized (monitor) {
                    logger.doLog(level, message, exception);
                }
            } else {
                logger.doLog(level, message, exception);
            }
        }
    }
    protected String getSecondsSinceLogInit() {
        return String.valueOf((System.currentTimeMillis() - loggerInitializationTime) / 1000);
    }
    /**
     * Internal method. Standard usage
     * <code>System.out</code>, to use it in different way
     * messages should be overloaded.
     *
     * @param level Message level
     * @param message Message content
     * @param exception Thread bundled with message or
     *        <code>null</code> if no thread bundled with message.
     */
    protected void doLog(int level, String message, Throwable exception) {
        System.out.print(getSecondsSinceLogInit() + ": ");
        try {
            System.out.print(levels[level]);
        } catch (ArrayIndexOutOfBoundsException e) {
            throw new Error("Blad logowania");
        }
        System.out.print(message);
        if (exception != null) {
            exception.printStackTrace();
        }
        System.out.println();
    }
    /**
     * Wysy
     *
     * @param level Level of the message to be logged.
     * @param message The message to be logged.
     */
    public static void log(int level, String message) {
        log(level, message, null);
    }
    /* Support methods. */
    public static void debug(String message) {
        log(DEBUG, message);
    }
    public static void debug(String message, Throwable t) {
        log(DEBUG, message, t);
    }
    public static void info(String message) {
        log(INFO, message);
    }
    public static void warn(String message) {
        log(WARN, message);
    }
    public static void warn(String message, Throwable t) {
        log(WARN, message, t);
    }
    public static void error(String message) {
        log(ERROR, message);
    }
    public static void error(String message, Throwable t) {
        log(ERROR, message, t);
    }
    /**
     * Messages filter level settings.
     */
    public static void setFilterAt(int level) {
        filterAt = level;
    }
    /**
     * Return messages filter level.
     */
    public static int getFilterAt() {
        return filterAt;
    }
    /**
     * Close login class.
     */
    public static void shutdown() {
        logger.shutdownInstance();
    }
    /**
     * Close instanse.
     */
    public void shutdownInstance() {
    }
}

package com.naviexpert.util;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Date;
import java.io.File;
 
public class LogServerListener {
    public final static int portNr = 9999;
    public static void println(Writer os, String arg) {
        System.out.print(arg);
        System.out.flush();
        try {
            os.write(arg);
            os.flush();
        } catch (IOException e) {
            // ignorujemy
            System.out.print("I/O exception: " + e.toString());
        }
    }
 
    public static void main(String[] args) throws UnknownHostException, IOException {
        if (args.length != 1) {
            System.out.println;
            return;
        }
        if (new File(args[0]).isDirectory() == false) {
            System.out.println("Wrong argument � directory not exist:" + args[0]);
            return;
        }
        final String dir = new File(args[0]).getPath() + File.separatorChar;
        ServerSocket socket = new ServerSocket(portNr);
        System.out.println("Port:" + portNr);
        int count = 0;
        while (true) {
            final Socket client = socket.accept();
            new Thread() {
                final PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(dir
                        + String.valueOf(new Date().getTime()))));
                public void run() {
                    try {
                        System.out.println("Save history in dir:" + dir);
                        println(out, "nn---------------------------nn");
                        InputStream is = client.getInputStream();
                        byte[] buf = new byte[1024 * 4];
                        while (true) {
                            int bytes = is.read(buf);
                            if (bytes == -1) break;
                            println(out, new String(buf, 0, bytes));
                        }
                    } catch (IOException e) {
                        try {
                            client.close();
                        } catch (IOException e1) {
                        }
                    }
                }
            }.start();
            count++;
        }
    }
}