1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.internal.logging; 18 19 import android.util.Log; 20 import dalvik.system.DalvikLogging; 21 import dalvik.system.DalvikLogHandler; 22 23 import java.io.PrintWriter; 24 import java.io.StringWriter; 25 import java.util.logging.Formatter; 26 import java.util.logging.Handler; 27 import java.util.logging.Level; 28 import java.util.logging.LogRecord; 29 import java.util.logging.Logger; 30 31 /** 32 * Implements a {@link java.util.logging.Logger} handler that writes to the Android log. The 33 * implementation is rather straightforward. The name of the logger serves as 34 * the log tag. Only the log levels need to be converted appropriately. For 35 * this purpose, the following mapping is being used: 36 * 37 * <table> 38 * <tr> 39 * <th>logger level</th> 40 * <th>Android level</th> 41 * </tr> 42 * <tr> 43 * <td> 44 * SEVERE 45 * </td> 46 * <td> 47 * ERROR 48 * </td> 49 * </tr> 50 * <tr> 51 * <td> 52 * WARNING 53 * </td> 54 * <td> 55 * WARN 56 * </td> 57 * </tr> 58 * <tr> 59 * <td> 60 * INFO 61 * </td> 62 * <td> 63 * INFO 64 * </td> 65 * </tr> 66 * <tr> 67 * <td> 68 * CONFIG 69 * </td> 70 * <td> 71 * DEBUG 72 * </td> 73 * </tr> 74 * <tr> 75 * <td> 76 * FINE, FINER, FINEST 77 * </td> 78 * <td> 79 * VERBOSE 80 * </td> 81 * </tr> 82 * </table> 83 */ 84 public class AndroidHandler extends Handler implements DalvikLogHandler { 85 /** 86 * Holds the formatter for all Android log handlers. 87 */ 88 private static final Formatter THE_FORMATTER = new Formatter() { 89 @Override 90 public String format(LogRecord r) { 91 Throwable thrown = r.getThrown(); 92 if (thrown != null) { 93 StringWriter sw = new StringWriter(); 94 PrintWriter pw = new PrintWriter(sw); 95 sw.write(r.getMessage()); 96 sw.write("\n"); 97 thrown.printStackTrace(pw); 98 pw.flush(); 99 return sw.toString(); 100 } else { 101 return r.getMessage(); 102 } 103 } 104 }; 105 106 /** 107 * Constructs a new instance of the Android log handler. 108 */ 109 public AndroidHandler() { 110 setFormatter(THE_FORMATTER); 111 } 112 113 @Override 114 public void close() { 115 // No need to close, but must implement abstract method. 116 } 117 118 @Override 119 public void flush() { 120 // No need to flush, but must implement abstract method. 121 } 122 123 @Override 124 public void publish(LogRecord record) { 125 int level = getAndroidLevel(record.getLevel()); 126 String tag = DalvikLogging.loggerNameToTag(record.getLoggerName()); 127 if (!Log.isLoggable(tag, level)) { 128 return; 129 } 130 131 try { 132 String message = getFormatter().format(record); 133 Log.println(level, tag, message); 134 } catch (RuntimeException e) { 135 Log.e("AndroidHandler", "Error logging message.", e); 136 } 137 } 138 139 public void publish(Logger source, String tag, Level level, String message) { 140 // TODO: avoid ducking into native 2x; we aren't saving any formatter calls 141 int priority = getAndroidLevel(level); 142 if (!Log.isLoggable(tag, priority)) { 143 return; 144 } 145 146 try { 147 Log.println(priority, tag, message); 148 } catch (RuntimeException e) { 149 Log.e("AndroidHandler", "Error logging message.", e); 150 } 151 } 152 153 /** 154 * Converts a {@link java.util.logging.Logger} logging level into an Android one. 155 * 156 * @param level The {@link java.util.logging.Logger} logging level. 157 * 158 * @return The resulting Android logging level. 159 */ 160 static int getAndroidLevel(Level level) { 161 int value = level.intValue(); 162 if (value >= 1000) { // SEVERE 163 return Log.ERROR; 164 } else if (value >= 900) { // WARNING 165 return Log.WARN; 166 } else if (value >= 800) { // INFO 167 return Log.INFO; 168 } else { 169 return Log.DEBUG; 170 } 171 } 172 } 173