/**
* Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR
* USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions
* for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
* "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is
* granting the License. "Legal Entity" shall mean the union of the acting entity and all other
* entities that control, are controlled by, or are under common control with that entity. For the
* purposes of this definition, "control" means (i) the power, direct or indirect, to cause the
* direction or management of such entity, whether by contract or otherwise, or (ii) ownership of
* fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such
* entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted
* by this License. "Source" form shall mean the preferred form for making modifications, including
* but not limited to software source code, documentation source, and configuration files. "Object"
* form shall mean any form resulting from mechanical transformation or translation of a Source
* form, including but not limited to compiled object code, generated documentation, and conversions
* to other media types. "Work" shall mean the work of authorship, whether in Source or Object form,
* made available under the License, as indicated by a copyright notice that is included in or
* attached to the work (an example is provided in the Appendix below). "Derivative Works" shall
* mean any work, whether in Source or Object form, that is based on (or derived from) the Work and
* for which the editorial revisions, annotations, elaborations, or other modifications represent,
* as a whole, an original work of authorship. For the purposes of this License, Derivative Works
* shall not include works that remain separable from, or merely link (or bind by name) to the
* interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of
* authorship, including the original version of the Work and any modifications or additions to that
* Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in
* the Work by the copyright owner or by an individual or Legal Entity authorized to submit on
* behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of
* electronic, verbal, or written communication sent to the Licensor or its representatives,
* including but not limited to communication on electronic mailing lists, source code control
* systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the
* purpose of discussing and improving the Work, but excluding communication that is conspicuously
* marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
* "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a
* Contribution has been received by Licensor and subsequently incorporated within the Work. 2.
* Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor
* hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
* copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform,
* sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant
* of Patent License. Subject to the terms and conditions of this License, each Contributor hereby
* grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except
* as stated in this section) patent license to make, have made, use, offer to sell, sell, import,
* and otherwise transfer the Work, where such license applies only to those patent claims
* licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or
* by combination of their Contribution(s) with the Work to which such Contribution(s) was
* submitted. If You institute patent litigation against any entity (including a cross-claim or
* counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work
* constitutes direct or contributory patent infringement, then any patent licenses granted to You
* under this License for that Work shall terminate as of the date such litigation is filed. 4.
* Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof
* in any medium, with or without modifications, and in Source or Object form, provided that You
* meet the following conditions: (a) You must give any other recipients of the Work or Derivative
* Works a copy of this License; and (b) You must cause any modified files to carry prominent
* notices stating that You changed the files; and (c) You must retain, in the Source form of any
* Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices
* from the Source form of the Work, excluding those notices that do not pertain to any part of the
* Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution,
* then any Derivative Works that You distribute must include a readable copy of the attribution
* notices contained within such NOTICE file, excluding those notices that do not pertain to any
* part of the Derivative Works, in at least one of the following places: within a NOTICE text file
* distributed as part of the Derivative Works; within the Source form or documentation, if provided
* along with the Derivative Works; or, within a display generated by the Derivative Works, if and
* wherever such third-party notices normally appear. The contents of the NOTICE file are for
* informational purposes only and do not modify the License. You may add Your own attribution
* notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE
* text from the Work, provided that such additional attribution notices cannot be construed as
* modifying the License. You may add Your own copyright statement to Your modifications and may
* provide additional or different license terms and conditions for use, reproduction, or
* distribution of Your modifications, or for any such Derivative Works as a whole, provided Your
* use, reproduction, and distribution of the Work otherwise complies with the conditions stated in
* this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any
* Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be
* under the terms and conditions of this License, without any additional terms or conditions.
* Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate
* license agreement you may have executed with Licensor regarding such Contributions. 6.
* Trademarks. This License does not grant permission to use the trade names, trademarks, service
* marks, or product names of the Licensor, except as required for reasonable and customary use in
* describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer
* of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the
* Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties
* or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.
* You are solely responsible for determining the appropriateness of using or redistributing the
* Work and assume any risks associated with Your exercise of permissions under this License. 8.
* Limitation of Liability. In no event and under no legal theory, whether in tort (including
* negligence), contract, or otherwise, unless required by applicable law (such as deliberate and
* grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for
* damages, including any direct, indirect, special, incidental, or consequential damages of any
* character arising as a result of this License or out of the use or inability to use the Work
* (including but not limited to damages for loss of goodwill, work stoppage, computer failure or
* malfunction, or any and all other commercial damages or losses), even if such Contributor has
* been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability.
* While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a
* fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights
* consistent with this License. However, in accepting such obligations, You may act only on Your
* own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if
* You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by,
* or claims asserted against, such Contributor by reason of your accepting any such warranty or
* additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to
* your work. To apply the Apache License to your work, attach the following boilerplate notice,
* with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't
* include the brackets!) The text should be enclosed in the appropriate comment syntax for the
* file format. We also recommend that a file or class name and description of purpose be included
* on the same "printed page" as the copyright notice for easier identification within third-party
* archives. Copyright 2016 Alibaba Group 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.taobao.weex.utils;
import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.util.Log;
import com.taobao.weex.WXEnvironment;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Method;
import java.util.HashMap;
public class WXLogUtils {
public static final String WEEX_TAG = "weex";
public static final String WEEX_PERF_TAG = "weex_perf";
public static boolean isShowLineNumber = false;
private static final String CLAZZ_NAME_DEBUG_TOOL = "com.taobao.weex.WXDebugTool";
private static final String CLAZZ_NAME_LOG_UTIL = "com.taobao.weex.devtools.common.LogUtil";
private static StringBuilder builder = new StringBuilder(50);
private static HashMap<String, Class> clazzMaps = new HashMap<>(2);
static {
clazzMaps.put(CLAZZ_NAME_DEBUG_TOOL, loadClass(CLAZZ_NAME_DEBUG_TOOL));
clazzMaps.put(CLAZZ_NAME_LOG_UTIL, loadClass(CLAZZ_NAME_LOG_UTIL));
}
private static Class loadClass(String clazzName) {
Class<?> clazz = null;
try {
clazz = Class.forName(clazzName);
if (clazz != null) {
clazzMaps.put(clazzName, clazz);
}
} catch (ClassNotFoundException e) {
// ignore
}
return clazz;
}
public static void renderPerformanceLog(String type, long time) {
if (WXEnvironment.isApkDebugable() || WXEnvironment.isPerf()) {
builder.setLength(0);
builder.append("[render time]").append(type).append(":").append(time);
Log.d(WEEX_PERF_TAG, getLineNumber() + builder.substring(0));
writeConsoleLog("debug", builder.substring(0));
}
}
private static void log(String tag, String msg, LogLevel level){
if (WXEnvironment.isApkDebugable() && msg != null && WXEnvironment.sLogLevel.compare(level) >= 0) {
msg = getLineNumber() + msg;
Log.println(level.getPriority(),tag, msg);
writeConsoleLog(level.getName(), msg);
sendLog(level, msg);
}
}
public static void d(String msg) {
d(WEEX_TAG,msg);
}
public static void i(String msg) {
i(WEEX_TAG,msg);
}
public static void info(String msg) {
i(WEEX_TAG,msg);
}
public static void v(String msg) {
v(WEEX_TAG,msg);
}
public static void w(String msg) {
w(WEEX_TAG,msg);
}
public static void e(String msg) {
e(WEEX_TAG,msg);
}
public static void d(String tag, byte[] msg) {
d(tag,new String(msg));
}
public static void d(String tag, String msg) {
if (WXEnvironment.isApkDebugable() && !TextUtils.isEmpty(msg) && WXEnvironment.sLogLevel.compare(LogLevel.DEBUG) >= 0) {
msg = getLineNumber() + msg;
Log.d(tag, msg);
/** This log method will be invoked from jni code, so try to extract loglevel from message. **/
writeConsoleLog("debug", tag + ":" + msg);
if(msg.contains(" | __")){
String[] msgs=msg.split(" | __");
LogLevel level;
if( msgs!=null && msgs.length==4 && !TextUtils.isEmpty(msgs[0]) && !TextUtils.isEmpty(msgs[2])){
level=getLogLevel(msgs[2]);
sendLog(level,msgs[0]);
return;
}
}
sendLog(LogLevel.DEBUG, tag + ":" + msg);
}
}
private static LogLevel getLogLevel(String level) {
switch (level.trim()){
case "__ERROR":
return LogLevel.ERROR;
case "__WARN":
return LogLevel.WARN;
case "__INFO":
return LogLevel.INFO;
case "__LOG":
return LogLevel.INFO;
case "__DEBUG":
return LogLevel.DEBUG;
}
return LogLevel.DEBUG;
}
public static void i(String tag, String msg) {
log(tag, msg,LogLevel.INFO);
}
public static void v(String tag, String msg) {
log(tag, msg,LogLevel.VERBOSE);
}
public static void w(String tag, String msg) {
log(tag, msg,LogLevel.WARN);
}
public static void e(String tag, String msg) {
log(tag, msg,LogLevel.ERROR);
}
/**
* 'p' for 'Performance', use {@link #WEEX_PERF_TAG}
* @param msg
*/
public static void p(String msg) {
d(WEEX_PERF_TAG,msg);
}
public static void d(String prefix, Throwable e) {
if (WXEnvironment.isApkDebugable()) {
d(prefix + getStackTrace(e));
}
}
public static void i(String prefix, Throwable e) {
if (WXEnvironment.isApkDebugable()) {
info(prefix + getStackTrace(e));
}
}
public static void v(String prefix, Throwable e) {
if (WXEnvironment.isApkDebugable()) {
v(prefix + getStackTrace(e));
}
}
public static void w(String prefix, Throwable e) {
if (WXEnvironment.isApkDebugable()) {
w(prefix + getStackTrace(e));
}
}
public static void e(String prefix, Throwable e) {
if (WXEnvironment.isApkDebugable()) {
e(prefix + getStackTrace(e));
}
}
/**
* 'p' for 'Performance', use {@link #WEEX_PERF_TAG}
*/
public static void p(String prefix, Throwable e) {
if (WXEnvironment.isApkDebugable()) {
p(prefix + getStackTrace(e));
}
}
public static void eTag(String tag, Throwable e) {
if (WXEnvironment.isApkDebugable()) {
e(tag, getStackTrace(e));
}
}
public static String getStackTrace(@Nullable Throwable e) {
if (e == null) {
return "";
}
StringWriter sw = null;
PrintWriter pw = null;
try {
sw = new StringWriter();
pw = new PrintWriter(sw);
e.printStackTrace(pw);
pw.flush();
sw.flush();
} finally {
if (sw != null) {
try {
sw.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (pw != null) {
pw.close();
}
}
return sw.toString();
}
private static void writeConsoleLog(String level, String message) {
if (WXEnvironment.isApkDebugable()) {
try {
Class<?> clazz = clazzMaps.get(CLAZZ_NAME_LOG_UTIL);
if (clazz != null) {
Method m = clazz.getMethod("log", String.class, String.class);
m.invoke(clazz, level, message);
}
} catch (Exception e) {
Log.d(WEEX_TAG, "LogUtil not found!");
}
}
}
private static void sendLog(LogLevel level, String msg) {
if(WXEnvironment.isApkDebugable()){
try {
Class<?> clazz = clazzMaps.get(CLAZZ_NAME_DEBUG_TOOL);
if (clazz != null) {
Method m = clazz.getMethod("sendLog", LogLevel.class,String.class);
m.invoke(clazz, level,msg);
}
} catch (Exception e) {
Log.d(WEEX_TAG, "WXDebugTool not found!");
}
}
}
/**
* Why the index is 2 ?
* StackTrace:
* 0 = com.taobao.weex.utils.WXLogUtils.getLineNumber
* 1 = com.taobao.weex.utils.WXLogUtils#x
* 2 = the actual caller
* …… more stack trace element
* */
private static String getLineNumber() {
if (!isShowLineNumber) {
return "";
}
StackTraceElement[] stackTrace = new Throwable().getStackTrace();
final int index = 2;
String className = stackTrace[index].getFileName();
int lineNum = stackTrace[index].getLineNumber();
return "(" + className + ":" + lineNum + ") ";
}
}