Android封装对原生Log进行封装的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.zjx.taobaounion.utils;
import android.util.Log;
public class LogUtils {
 private static int currentLev = 4; // 当前log等级 上线之后控制这个等级 就可以减少Log的输出
 private static final int DEBUG_LEV = 4; // debug 等级
 private static final int INFO_LEV = 3; // info 等级
 private static final int WARNING_LEV = 2; // warning 等级
 private static final int ERROR_LEV = 1; // error 等级
 public static void d(Class clazz,String log){
  if (currentLev >= DEBUG_LEV) {
   // 如果当前设置的等级 大于等于 debug等级 那么就证明当前不屏蔽debug的log输出
   Log.d(clazz.getSimpleName(),log);
  }
 }
 public static void i(Class clazz,String log){
  if (currentLev >= INFO_LEV) {
   // 如果当前设置的等级 大于等于 info 那么就证明当前不屏蔽info的log输出
   Log.i(clazz.getSimpleName(),log);
  }
 }
 public static void w(Class clazz,String log){
  if (currentLev >= WARNING_LEV) {
   // 如果当前设置的等级 大于等于 warning 那么就证明当前不屏蔽warning的log输出
   Log.w(clazz.getSimpleName(),log);
  }
 }
 public static void e(Class clazz,String log){
  if (currentLev >= ERROR_LEV) {
   // 如果当前设置的等级 大于等于 error 那么就证明当前不屏蔽error的log输出
   Log.e(clazz.getSimpleName(),log);
  }
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
import android.text.TextUtils;
import android.util.Log;
import com.smartlink.suixing.App;
import com.smartlink.suixing.BuildConfig;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Formatter;
import java.util.Locale;
public class LogUtils {
	public static String			customTagPrefix	= "log";	// 自定义Tag的前缀，可以是作者名
	private static final boolean	isSaveLog		= true;		// 是否把保存日志到SD卡中
	private static String			cacheDirPath;
	private LogUtils() {
	}
	// 容许打印日志的类型，默认是true，设置为false则不打印
	public static boolean	allowD		= BuildConfig.DEBUG;
	public static boolean	allowE		= BuildConfig.DEBUG;
	public static boolean	allowI		= BuildConfig.DEBUG;
	public static boolean	allowV		= BuildConfig.DEBUG;
	public static boolean	allowW		= BuildConfig.DEBUG;
	public static boolean	allowWtf	= BuildConfig.DEBUG;
	// public static boolean allowD = true;
	// public static boolean allowE = true;
	// public static boolean allowI = true;
	// public static boolean allowV = true;
	// public static boolean allowW = true;
	// public static boolean allowWtf = true;
	private static String generateTag(StackTraceElement caller) {
		String tag = "%s.%s(Line:%d)"; // 占位符
		String callerClazzName = caller.getClassName(); // 获取到类名
		callerClazzName = callerClazzName.substring(callerClazzName.lastIndexOf(".") + 1);
		tag = String.format(tag, callerClazzName, caller.getMethodName(), caller.getLineNumber()); // 替换
		tag = TextUtils.isEmpty(customTagPrefix) ? tag : customTagPrefix + ":" + tag;
		return tag;
	}
	/***
	 * 打印控制台显示不了那么长的日志问题
	 * 
	 * @param msg
	 */
	public static void logE(String msg) { // 信息太长,分段打印
		if (!allowE) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		// 因为String的length是字符数量不是字节数量所以为了防止中文字符过多，
		// 把4*1024的MAX字节打印长度改为2001字符数
		int max_str_length = 2001 - tag.length();
		// 大于4000时
		while (msg.length() > max_str_length) {
			// Log.e(tag, msg.substring(0, max_str_length));
			LogUtils.e(msg.substring(0, max_str_length));
			msg = msg.substring(max_str_length);
		}
		// 剩余部分
		// Log.e(tag, msg);
		LogUtils.e(msg);
	}
	/**
	 * 自定义的logger
	 */
	public static CustomLogger customLogger;
	public interface CustomLogger {
		void d(String tag, String content);
		void d(String tag, String content, Throwable tr);
		void e(String tag, String content);
		void e(String tag, String content, Throwable tr);
		void i(String tag, String content);
		void i(String tag, String content, Throwable tr);
		void v(String tag, String content);
		void v(String tag, String content, Throwable tr);
		void w(String tag, String content);
		void w(String tag, String content, Throwable tr);
		void w(String tag, Throwable tr);
		void wtf(String tag, String content);
		void wtf(String tag, String content, Throwable tr);
		void wtf(String tag, Throwable tr);
	}
	public static void d(String content) {
		if (!allowD) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.d(tag, content);
		} else {
			Log.d(tag, content);
		}
	}
	public static void d(String content, Throwable tr) {
		if (!allowD) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.d(tag, content, tr);
		} else {
			Log.d(tag, content, tr);
		}
	}
	public static void e(String content) {
		if (!allowE) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.e(tag, content);
		} else {
			Log.e(tag, content);
		}
		if (isSaveLog) {
			point(cacheDirPath, tag, content);
		}
	}
	public static void e(String content, Throwable tr) {
		if (!allowE) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.e(tag, content, tr);
		} else {
			Log.e(tag, content, tr);
		}
		if (isSaveLog) {
			point(cacheDirPath, tag, tr.getMessage());
		}
	}
	public static void e(Throwable tr) {
		if (!allowE) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.e(tag, "", tr);
		} else {
			Log.e(tag, "", tr);
		}
		if (isSaveLog) {
			point(cacheDirPath, tag, tr.getMessage());
		}
	}
	public static void i(String content) {
		if (!allowI) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.i(tag, content);
		} else {
			Log.i(tag, content);
		}
	}
	public static void i(String content, Throwable tr) {
		if (!allowI) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.i(tag, content, tr);
		} else {
			Log.i(tag, content, tr);
		}
	}
	public static void v(String content) {
		if (!allowV) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.v(tag, content);
		} else {
			Log.v(tag, content);
		}
	}
	public static void v(String content, Throwable tr) {
		if (!allowV) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.v(tag, content, tr);
		} else {
			Log.v(tag, content, tr);
		}
	}
	public static void w(String content) {
		if (!allowW) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.w(tag, content);
		} else {
			Log.w(tag, content);
		}
	}
	public static void w(String content, Throwable tr) {
		if (!allowW) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.w(tag, content, tr);
		} else {
			Log.w(tag, content, tr);
		}
	}
	public static void w(Throwable tr) {
		if (!allowW) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.w(tag, tr);
		} else {
			Log.w(tag, tr);
		}
	}
	public static void wtf(String content) {
		if (!allowWtf) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.wtf(tag, content);
		} else {
			Log.wtf(tag, content);
		}
	}
	public static void wtf(String content, Throwable tr) {
		if (!allowWtf) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.wtf(tag, content, tr);
		} else {
			Log.wtf(tag, content, tr);
		}
	}
	public static void wtf(Throwable tr) {
		if (!allowWtf) return;
		StackTraceElement caller = getCallerStackTraceElement();
		String tag = generateTag(caller);
		if (customLogger != null) {
			customLogger.wtf(tag, tr);
		} else {
			Log.wtf(tag, tr);
		}
	}
	private static StackTraceElement getCallerStackTraceElement() {
		return Thread.currentThread().getStackTrace()[4];
	}
	public static void point(String path, String tag, String msg) {
		if (isSDAva()) {
			path = cacheDirPath;
			Date date = new Date();
			SimpleDateFormat dateFormat = new SimpleDateFormat("", Locale.SIMPLIFIED_CHINESE);
			dateFormat.applyPattern("yyyy");
			path = path + dateFormat.format(date) + "/";
			dateFormat.applyPattern("MM");
			path += dateFormat.format(date) + "/";
			dateFormat.applyPattern("dd");
			path += dateFormat.format(date) + ".log";
			dateFormat.applyPattern("[yyyy-MM-dd HH:mm:ss]");
			String time = dateFormat.format(date);
			File file = new File(path);
			if (!file.exists()) createDipPath(path);
			BufferedWriter out = null;
			try {
				out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true)));
				out.write(time + " " + tag + " " + msg + "rn");
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				try {
					if (out != null) {
						out.close();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	/**
	 * 根据文件路径 递归创建文件
	 * 
	 * @param file
	 */
	public static void createDipPath(String file) {
		String parentFile = file.substring(0, file.lastIndexOf("/"));
		File file1 = new File(file);
		File parent = new File(parentFile);
		if (!file1.exists()) {
			parent.mkdirs();
			try {
				file1.createNewFile();
				LogUtils.e("日志文件的路径是" + file1.getAbsolutePath());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	/**
	 * A little trick to reuse a formatter in the same thread
	 */
	private static class ReusableFormatter {
		private Formatter		formatter;
		private StringBuilder	builder;
		public ReusableFormatter() {
			builder = new StringBuilder();
			formatter = new Formatter(builder);
		}
		public String format(String msg, Object... args) {
			formatter.format(msg, args);
			String s = builder.toString();
			builder.setLength(0);
			return s;
		}
	}
	private static final ThreadLocal<ReusableFormatter> thread_local_formatter = new ThreadLocal<ReusableFormatter>() {
		protected ReusableFormatter initialValue() {
			return new ReusableFormatter();
		}
	};
	public static String format(String msg, Object... args) {
		ReusableFormatter formatter = thread_local_formatter.get();
		return formatter.format(msg, args);
	}
	public static boolean isSDAva() {
		if (cacheDirPath == null) cacheDirPath = App.getAppContext().getExternalFilesDir("log").getAbsolutePath();
		if (!TextUtils.isEmpty(cacheDirPath)) {
			return true;
		} else {
			return false;
		}
	}
}