मैं उदाहरण के लिए डिबग करने के लिए लॉगिंग स्टेटमेंट के बहुत सारे हैं।
Log.v(TAG, "Message here");
Log.w(TAG, " WARNING HERE");डिवाइस फोन पर इस एप्लिकेशन को तैनात करते समय मैं क्रिया लॉगिंग को बंद करना चाहता हूं जहां से मैं लॉगिंग को सक्षम / अक्षम कर सकता हूं।
जवाबों:
एक सामान्य तरीका यह है कि एक नामित लॉजवेल बनाया जाए, और अपने डिबग स्तर को लैगवेल के आधार पर परिभाषित किया जाए।
public static int LOGLEVEL = 2;
public static boolean ERROR = LOGLEVEL > 0;
public static boolean WARN = LOGLEVEL > 1;
...
public static boolean VERBOSE = LOGLEVEL > 4;
if (VERBOSE) Log.v(TAG, "Message here"); // Won't be shown
if (WARN) Log.w(TAG, "WARNING HERE"); // Still goes throughबाद में, आप केवल सभी डिबग आउटपुट स्तर के लिए LOGLEVEL बदल सकते हैं।
एंड्रॉयड प्रलेखन लॉग स्तर के बारे में निम्नलिखित का कहना है :
वर्बोज़ को विकास के दौरान कभी भी एक आवेदन में संकलित नहीं किया जाना चाहिए। डिबग लॉग संकलित हैं, लेकिन रनटाइम पर छीन लिए गए हैं। त्रुटि, चेतावनी और सूचना लॉग हमेशा रखे जाते हैं।
तो आप लॉग वर्बोस लॉगिंग स्टेटमेंट को अलग करने पर विचार कर सकते हैं, संभवतः प्रोगार्ड का उपयोग करके जैसा कि एक अन्य उत्तर में दिया गया है ।
प्रलेखन के अनुसार, आप सिस्टम गुण का उपयोग करके एक विकास डिवाइस पर लॉगिंग को कॉन्फ़िगर कर सकते हैं। सेट करने के लिए संपत्ति है log.tag.<YourTag>और यह निम्नलिखित में से एक मान सेट किया जाना चाहिए: VERBOSE, DEBUG, INFO, WARN, ERROR, ASSERT, या SUPPRESS। इस पर अधिक जानकारी isLoggable()विधि के लिए प्रलेखन में उपलब्ध है ।
आप अस्थायी रूप से setpropकमांड का उपयोग करके गुण सेट कर सकते हैं । उदाहरण के लिए:
C:\android>adb shell setprop log.tag.MyAppTag WARN
C:\android>adb shell getprop log.tag.MyAppTag
WARNवैकल्पिक रूप से, आप उन्हें फ़ाइल में निर्दिष्ट कर सकते हैं '/data/local.prop' इस प्रकार है:
log.tag.MyAppTag=WARNAndroid के बाद के संस्करणों के लिए आवश्यक है कि /data/local.prop को केवल पढ़ा जाए । यह फ़ाइल बूट समय पर पढ़ी जाती है इसलिए आपको इसे अपडेट करने के बाद पुनरारंभ करना होगा। यदि /data/local.propविश्व में लेखन योग्य है, तो इसे अनदेखा किया जाएगा।
अंत में, आप उन्हें System.setProperty()विधि का उपयोग करके प्रोग्रामेटिक रूप से सेट कर सकते हैं ।
android.util.Configस्थिरांक का उल्लेख किया गया प्रतीत होता है । एपीआई डॉक्स में निर्दिष्ट हार्डकोड वैल्यू बेकार हैं क्योंकि ये (माना जाता है) बिल्ड द्वारा अलग-अलग होते हैं। इसलिए ProGuard मार्ग हमारे लिए सबसे अच्छा समाधान था।
सबसे आसान तरीका संभवत : तैनाती से पहले प्रोगार्ड के माध्यम से अपने संकलित JAR को चलाना है , जैसे कि एक विन्यास के साथ:
-assumenosideeffects class android.util.Log {
public static int v(...);
}वह होगा - एक तरफ सभी अन्य ProGuard ऑप्टिमाइजेशन से अलग - सीधे बायटेकोड से किसी भी वर्बोज़ लॉग स्टेटमेंट को हटा दें।
मैंने एक सरल मार्ग लिया - एक रैपर वर्ग बनाया जो चर पैरामीटर सूचियों का भी उपयोग करता है।
public class Log{
public static int LEVEL = android.util.Log.WARN;
static public void d(String tag, String msgFormat, Object...args)
{
if (LEVEL<=android.util.Log.DEBUG)
{
android.util.Log.d(tag, String.format(msgFormat, args));
}
}
static public void d(String tag, Throwable t, String msgFormat, Object...args)
{
if (LEVEL<=android.util.Log.DEBUG)
{
android.util.Log.d(tag, String.format(msgFormat, args), t);
}
}
//...other level logging functions snippedबेहतर तरीका यह है कि इसके कुछ कार्यान्वयन SLF4J API + का उपयोग किया जाए।
Android एप्लिकेशन के लिए आप निम्नलिखित का उपयोग कर सकते हैं:
logback-android(चूंकि logbackउचित असंगत है)। logback-android-1.0.10-1.jar429 KB है, जो प्रदान की गई सुविधाओं को देखते हुए बहुत बुरा नहीं है, लेकिन अधिकांश डेवलपर्स वैसे भी अपने आवेदन का अनुकूलन करने के लिए Proguard का उपयोग करेंगे।
आपको उपयोग करना चाहिए
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "my log message");
}लॉगिंग को प्रोगार्ड के साथ स्ट्रिप करना (@Christopher से उत्तर देखें) आसान और तेज़ था, लेकिन इसने फ़ाइल में कोई डीबग लॉगिंग होने पर स्रोत को बेमेल करने के लिए उत्पादन से स्टैक के निशान का कारण बना।
इसके बजाय, यहां एक ऐसी तकनीक है जो विकास बनाम उत्पादन में विभिन्न लॉगिंग स्तरों का उपयोग करती है, यह मानते हुए कि प्रोगार्ड का उपयोग केवल उत्पादन में किया जाता है। यह देखने से उत्पादन को पहचानता है कि क्या किसी गार्ड ने किसी दिए गए वर्ग का नाम बदल दिया है (उदाहरण के लिए, मैं "com.foo.Bar" का उपयोग करता हूं - आप इसे पूरी तरह से योग्य वर्ग के नाम से बदल देंगे जिसे आप जानते हैं कि उसका नाम बदलकर प्राग कर दिया जाएगा)।
यह तकनीक कॉमन्स लॉगिंग का उपयोग करती है।
private void initLogging() {
Level level = Level.WARNING;
try {
// in production, the shrinker/obfuscator proguard will change the
// name of this class (and many others) so in development, this
// class WILL exist as named, and we will have debug level
Class.forName("com.foo.Bar");
level = Level.FINE;
} catch (Throwable t) {
// no problem, we are in production mode
}
Handler[] handlers = Logger.getLogger("").getHandlers();
for (Handler handler : handlers) {
Log.d("log init", "handler: " + handler.getClass().getName());
handler.setLevel(level);
}
}Log4j या slf4j को भी logcat के साथ एंड्रॉइड में लॉगिंग फ्रेमवर्क के रूप में उपयोग किया जा सकता है। एंड्रॉइड में प्रोजेक्ट एंड्रॉइड-लॉगिंग-लॉग 4 जे या लॉग 4 जे समर्थन देखें
मानक Android लॉग वर्ग के लिए एक छोटा ड्रॉप-इन प्रतिस्थापन है - https://github.com/zserge/log
मूल रूप से आपको बस इतना करना है कि आयात को किस से बदलना android.util.Logहै trikita.log.Log। फिर आपके Application.onCreate()या कुछ स्थैतिक initalizer में BuilConfig.DEBUGया किसी अन्य ध्वज के लिए जाँच करें और न्यूनतम लॉग स्तर को बदलने Log.level(Log.D)या उपयोग Log.level(Log.E)करने के लिए। आप Log.useLog(false)लॉगिंग को अक्षम करने के लिए उपयोग कर सकते हैं ।
हो सकता है आप इस लॉग एक्सटेंशन क्लास को देख सकते हैं: https://github.com/dbauduin/Android-Tools/tree/master/logs ।
यह आपको लॉग पर एक अच्छा नियंत्रण रखने में सक्षम बनाता है। आप उदाहरण के लिए सभी लॉग या कुछ पैकेज या कक्षाओं के लॉग को अक्षम कर सकते हैं।
इसके अलावा, यह कुछ उपयोगी फ़ंक्शंस जोड़ता है (उदाहरण के लिए आपको प्रत्येक लॉग के लिए एक टैग पास करने की आवश्यकता नहीं है)।
मैंने एक उपयोगिता / आवरण तैयार किया जो लॉगिंग के आसपास इस समस्या + अन्य सामान्य समस्याओं को हल करता है।
निम्नलिखित सुविधाओं के साथ एक डीबगिंग उपयोगिता:
कैसे इस्तेमाल करे?
मैंने प्रलेखन को आत्मनिर्भर बनाने की कोशिश की है।
इस उपयोगिता में सुधार के सुझावों का स्वागत है।
नि: शुल्क उपयोग / साझा करने के लिए।
इसे GitHub से डाउनलोड करें ।
यहां एक अधिक जटिल समाधान है। आपको पूर्ण स्टैक ट्रेस मिल जाएगा और विधि (toString) को केवल जरूरत (प्रदर्शन) कहा जाएगा। विशेषता BuildConfig.DEBUG उत्पादन मोड में गलत होगा, इसलिए सभी ट्रेस और डीबग लॉग हटा दिए जाएंगे। हॉट स्पॉट कंपाइलर के पास अंतिम स्थैतिक गुणों के कारण कॉल को हटाने का मौका है।
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import android.util.Log;
public class Logger {
public enum Level {
error, warn, info, debug, trace
}
private static final String DEFAULT_TAG = "Project";
private static final Level CURRENT_LEVEL = BuildConfig.DEBUG ? Level.trace : Level.info;
private static boolean isEnabled(Level l) {
return CURRENT_LEVEL.compareTo(l) >= 0;
}
static {
Log.i(DEFAULT_TAG, "log level: " + CURRENT_LEVEL.name());
}
private String classname = DEFAULT_TAG;
public void setClassName(Class<?> c) {
classname = c.getSimpleName();
}
public String getClassname() {
return classname;
}
public boolean isError() {
return isEnabled(Level.error);
}
public boolean isWarn() {
return isEnabled(Level.warn);
}
public boolean isInfo() {
return isEnabled(Level.info);
}
public boolean isDebug() {
return isEnabled(Level.debug);
}
public boolean isTrace() {
return isEnabled(Level.trace);
}
public void error(Object... args) {
if (isError()) Log.e(buildTag(), build(args));
}
public void warn(Object... args) {
if (isWarn()) Log.w(buildTag(), build(args));
}
public void info(Object... args) {
if (isInfo()) Log.i(buildTag(), build(args));
}
public void debug(Object... args) {
if (isDebug()) Log.d(buildTag(), build(args));
}
public void trace(Object... args) {
if (isTrace()) Log.v(buildTag(), build(args));
}
public void error(String msg, Throwable t) {
if (isError()) error(buildTag(), msg, stackToString(t));
}
public void warn(String msg, Throwable t) {
if (isWarn()) warn(buildTag(), msg, stackToString(t));
}
public void info(String msg, Throwable t) {
if (isInfo()) info(buildTag(), msg, stackToString(t));
}
public void debug(String msg, Throwable t) {
if (isDebug()) debug(buildTag(), msg, stackToString(t));
}
public void trace(String msg, Throwable t) {
if (isTrace()) trace(buildTag(), msg, stackToString(t));
}
private String buildTag() {
String tag ;
if (BuildConfig.DEBUG) {
StringBuilder b = new StringBuilder(20);
b.append(getClassname());
StackTraceElement stackEntry = Thread.currentThread().getStackTrace()[4];
if (stackEntry != null) {
b.append('.');
b.append(stackEntry.getMethodName());
b.append(':');
b.append(stackEntry.getLineNumber());
}
tag = b.toString();
} else {
tag = DEFAULT_TAG;
}
}
private String build(Object... args) {
if (args == null) {
return "null";
} else {
StringBuilder b = new StringBuilder(args.length * 10);
for (Object arg : args) {
if (arg == null) {
b.append("null");
} else {
b.append(arg);
}
}
return b.toString();
}
}
private String stackToString(Throwable t) {
ByteArrayOutputStream baos = new ByteArrayOutputStream(500);
baos.toString();
t.printStackTrace(new PrintStream(baos));
return baos.toString();
}
}इस तरह का उपयोग करें:
Loggor log = new Logger();
Map foo = ...
List bar = ...
log.error("Foo:", foo, "bar:", bar);
// bad example (avoid something like this)
// log.error("Foo:" + " foo.toString() + "bar:" + bar); एक बहुत ही सरल लॉगिंग परिदृश्य में, जहाँ आप वस्तुतः डिबगिंग उद्देश्यों के लिए विकास के दौरान सांत्वना देने के लिए लिखने का प्रयास कर रहे हैं, यह आसान हो सकता है कि आप अपने उत्पादन के निर्माण से पहले एक खोज करें और प्रतिस्थापित करें और लॉग या सिस्टम पर सभी कॉल्स को टिप्पणी दें। out.println।
उदाहरण के लिए, मान लें कि आपने "लॉग" का उपयोग नहीं किया है। Log.d या Log.e, आदि के लिए एक कॉल के बाहर कहीं भी, आप बस "लॉग को बदलने के लिए संपूर्ण समाधान में एक खोज और प्रतिस्थापित कर सकते हैं।" "// लॉग" के साथ। अपने सभी लॉगिंग कॉल्स पर टिप्पणी करने के लिए, या मेरे मामले में मैं हर जगह System.out.println का उपयोग कर रहा हूं, इसलिए उत्पादन पर जाने से पहले मैं बस एक पूरी खोज करूंगा और "System.out.println" को बदल दूंगा और उसके साथ बदल दूंगा "//System.out.println"।
मुझे पता है कि यह आदर्श नहीं है, और यह अच्छा होगा यदि लॉग और System.out.println में कॉल को खोजने और टिप्पणी करने की क्षमता ग्रहण में बनाई गई थी, लेकिन जब तक ऐसा करने का सबसे आसान और सबसे तेज़ और सबसे अच्छा तरीका होता है। खोज और प्रतिस्थापित करने के लिए टिप्पणी करना। यदि आप ऐसा करते हैं, तो आपको स्टैम्प ट्रेस लाइन नंबरों को मिसमैच करने के बारे में चिंता करने की ज़रूरत नहीं है, क्योंकि आप अपना स्रोत कोड संपादित कर रहे हैं, और आप कुछ लॉग लेवल कॉन्फ़िगरेशन, आदि की जाँच करके कोई ओवरहेड नहीं जोड़ रहे हैं।
मेरे ऐप्स में मेरे पास एक वर्ग है जो लॉग क्लास को लपेटता है जिसमें "स्टेट" नामक एक स्थिर बूलियन संस्करण है। मेरे कोड के दौरान मैं वास्तव में लॉग में लिखने से पहले एक स्थिर विधि का उपयोग करके "राज्य" चर के मूल्य की जांच करता हूं। मेरे पास "स्टेट" वैरिएबल सेट करने के लिए एक स्थिर तरीका है, जो यह सुनिश्चित करता है कि ऐप द्वारा बनाए गए सभी इंस्टेंसेस में मूल्य सामान्य है। इसका मतलब है कि मैं एक कॉल में ऐप के लिए सभी लॉगिंग को सक्षम या अक्षम कर सकता हूं - तब भी जब ऐप चल रहा हो। समर्थन कॉल के लिए उपयोगी ... इसका मतलब यह है कि आपको डिबगिंग करने के लिए अपनी बंदूकों से चिपके रहना होगा और मानक लॉग वर्ग का उपयोग करने के लिए फिर से प्राप्त नहीं करना होगा, हालांकि ...
यह भी उपयोगी (सुविधाजनक) है कि जावा एक बूलियन संस्करण की गलत व्याख्या करता है यदि इसे एक मान नहीं सौंपा गया है, जिसका अर्थ है कि इसे तब तक झूठा छोड़ा जा सकता है जब तक कि आपको लॉगिंग चालू करने की आवश्यकता न हो :-)
हम Logअपने स्थानीय घटक में कक्षा का उपयोग कर सकते हैं और विधियों को v / i / e / d के रूप में परिभाषित कर सकते हैं । जरूरत के आधार पर हम आगे भी कॉल कर सकते हैं।
उदाहरण नीचे दिखाया गया है।
public class Log{
private static boolean TAG = false;
public static void d(String enable_tag, String message,Object...args){
if(TAG)
android.util.Log.d(enable_tag, message+args);
}
public static void e(String enable_tag, String message,Object...args){
if(TAG)
android.util.Log.e(enable_tag, message+args);
}
public static void v(String enable_tag, String message,Object...args){
if(TAG)
android.util.Log.v(enable_tag, message+args);
}
}
if we do not need any print(s), at-all make TAG as false for all else
remove the check for type of Log (say Log.d).
as
public static void i(String enable_tag, String message,Object...args){
// if(TAG)
android.util.Log.i(enable_tag, message+args);
}यहां संदेश के लिए है stringऔर argsवह मूल्य है जिसे आप प्रिंट करना चाहते हैं।
मेरे लिए यह अक्सर उपयोगी होता है कि हम प्रत्येक TAG के लिए विभिन्न लॉग स्तर सेट कर सकें।
मैं इस बहुत सरल आवरण वर्ग का उपयोग कर रहा हूं:
public class Log2 {
public enum LogLevels {
VERBOSE(android.util.Log.VERBOSE), DEBUG(android.util.Log.DEBUG), INFO(android.util.Log.INFO), WARN(
android.util.Log.WARN), ERROR(android.util.Log.ERROR);
int level;
private LogLevels(int logLevel) {
level = logLevel;
}
public int getLevel() {
return level;
}
};
static private HashMap<String, Integer> logLevels = new HashMap<String, Integer>();
public static void setLogLevel(String tag, LogLevels level) {
logLevels.put(tag, level.getLevel());
}
public static int v(String tag, String msg) {
return Log2.v(tag, msg, null);
}
public static int v(String tag, String msg, Throwable tr) {
if (logLevels.containsKey(tag)) {
if (logLevels.get(tag) > android.util.Log.VERBOSE) {
return -1;
}
}
return Log.v(tag, msg, tr);
}
public static int d(String tag, String msg) {
return Log2.d(tag, msg, null);
}
public static int d(String tag, String msg, Throwable tr) {
if (logLevels.containsKey(tag)) {
if (logLevels.get(tag) > android.util.Log.DEBUG) {
return -1;
}
}
return Log.d(tag, msg);
}
public static int i(String tag, String msg) {
return Log2.i(tag, msg, null);
}
public static int i(String tag, String msg, Throwable tr) {
if (logLevels.containsKey(tag)) {
if (logLevels.get(tag) > android.util.Log.INFO) {
return -1;
}
}
return Log.i(tag, msg);
}
public static int w(String tag, String msg) {
return Log2.w(tag, msg, null);
}
public static int w(String tag, String msg, Throwable tr) {
if (logLevels.containsKey(tag)) {
if (logLevels.get(tag) > android.util.Log.WARN) {
return -1;
}
}
return Log.w(tag, msg, tr);
}
public static int e(String tag, String msg) {
return Log2.e(tag, msg, null);
}
public static int e(String tag, String msg, Throwable tr) {
if (logLevels.containsKey(tag)) {
if (logLevels.get(tag) > android.util.Log.ERROR) {
return -1;
}
}
return Log.e(tag, msg, tr);
}
}अब बस प्रत्येक कक्षा की शुरुआत में लॉग स्तर प्रति टैग सेट करें:
Log2.setLogLevel(TAG, LogLevels.INFO);दूसरा तरीका लॉगिंग प्लेटफॉर्म का उपयोग करना है जिसमें लॉग खोलने और बंद करने की क्षमता है। यह कभी-कभी उत्पादन ऐप पर भी बहुत अधिक लचीलापन दे सकता है जो लॉग खुले होने चाहिए और जो उदाहरण के लिए आपके पास मौजूद मुद्दों के आधार पर बंद है: