blob: a6a4c6461d5b08c4764cfb0b816216f901484123 [file] [log] [blame]
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.logging;
import android.util.Log;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.SimpleFormatter;
/**
* Implements a {@link java.util.Logger} handler that writes to the Android log. The
* implementation is rather straightforward. The name of the logger serves as
* the log tag. Only the log levels need to be converted appropriately. For
* this purpose, the following mapping is being used:
*
* <table>
* <tr>
* <th>logger level</th>
* <th>Android level</th>
* </tr>
* <tr>
* <td>
* SEVERE
* </td>
* <td>
* ERROR
* </td>
* </tr>
* <tr>
* <td>
* WARNING
* </td>
* <td>
* WARN
* </td>
* </tr>
* <tr>
* <td>
* INFO
* </td>
* <td>
* INFO
* </td>
* </tr>
* <tr>
* <td>
* CONFIG
* </td>
* <td>
* DEBUG
* </td>
* </tr>
* <tr>
* <td>
* FINE, FINER, FINEST
* </td>
* <td>
* VERBOSE
* </td>
* </tr>
* </table>
*/
public class AndroidHandler extends Handler {
/**
* Holds the formatter for all Android log handlers.
*/
private static final Formatter THE_FORMATTER = new SimpleFormatter();
/**
* Constructs a new instance of the Android log handler.
*/
public AndroidHandler() {
setFormatter(THE_FORMATTER);
}
@Override
public void close() {
// No need to close, but must implement abstract method.
}
@Override
public void flush() {
// No need to flush, but must implement abstract method.
}
@Override
public void publish(LogRecord record) {
try {
int level = getAndroidLevel(record.getLevel());
String tag = record.getLoggerName();
if (!Log.isLoggable(tag, level)) {
return;
}
String msg;
try {
msg = getFormatter().format(record);
} catch (RuntimeException e) {
Log.e("AndroidHandler", "Error formatting log record", e);
msg = record.getMessage();
}
Log.println(level, tag, msg);
} catch (RuntimeException e) {
Log.e("AndroidHandler", "Error publishing log record", e);
}
}
/**
* Converts a {@link java.util.Logger} logging level into an Android one.
*
* @param level The {@link java.util.Logger} logging level.
*
* @return The resulting Android logging level.
*/
static int getAndroidLevel(Level level)
{
int value = level.intValue();
if (value >= Level.SEVERE.intValue()) {
return Log.ERROR;
} else if (value >= Level.WARNING.intValue()) {
return Log.WARN;
} else if (value >= Level.INFO.intValue()) {
return Log.INFO;
} else if (value >= Level.CONFIG.intValue()) {
return Log.DEBUG;
} else {
return Log.VERBOSE;
}
}
}