स्ट्रीम एंड्रॉयड logcat एक एसडी कार्ड

Question

के उत्पादन मैं प्राप्त करने के लिए निम्न लेकिन अभी तक, जब एंड्रॉयड आवेदन पहली बार शुरू किया नहीं भाग्य

• एक में एसडी कार्ड फ़ाइल खुला है चाहता हूँ।
• फ़ाइल में लॉगक आउटपुट स्ट्रीम करें।
• जब एप्लिकेशन निकलता है, तो लॉगक स्ट्रीमिंग को रोकें।

मेरी ApplicationClass में फैली आवेदन OnCreate() विधि, मैं इस

wwLogManager.openLogFile(); 

करते हैं और यहाँ) openLogFile (में कोड

 private static final String LOGCAT_COMMAND = "logcat -v time -f "; 
     String timestamp = Long.toString(System.currentTimeMillis()); 
     String logFileName = BuildConstants.LOG_LOCATION + "_" + timestamp + ".log";      
     mLogFile = new File(Environment.getExternalStorageDirectory() + logFileName); 
     mLogFile.createNewFile(); 
     String cmd = LOGCAT_COMMAND + mLogFile.getAbsolutePath(); 
     Runtime.getRuntime().exec(cmd); 

मैं एसडी में लॉग फ़ाइलें प्राप्त करते हैं कार्ड, लेकिन इन फ़ाइलों में लॉग आउटपुट में Log.i() कॉल का कोई निशान नहीं है जिसे मैंने अपनी गतिविधियों में रखा था। क्या लॉगक कमांड है जिसे मैंने यहां सही इस्तेमाल किया है? धन्यवाद!

Answer 1

को यहां बताए गए एक फिल्टर की स्थापना मैन्युअल रूप से प्रयास करें: http://developer.android.com/guide/developing/debugging/debugging-log.html#filteringOutput

कुछ की तरह:

logcat ActivityManager:I MyApp:V *:S 

आपको लगता है कि आप उपयोग कर रहे लॉग टैग के साथ बदलते हैं "MyApp", कि आप सभी की जानकारी दिखाना चाहिए (और अधिक) ActivityManager से लॉग, और आपके ऐप से सभी वर्बोज़ (और अधिक) लॉग।

Answer 2

अगर मैं आपके लक्ष्यों को गलत समझ रहा हूं, तो मैं क्षमा चाहता हूं, लेकिन शायद आप लॉगकैट या एंड्रॉइड लॉगिंग तंत्र का उपयोग करने के बजाय java.util.logging API का उपयोग कर सकते हैं।

एंड्रॉयड प्रवेश एपीआई की तरह, java.util.logging API आप आसानी से इस तरह के फाइन, बेहतर, चेतावनी, गंभीर, आदि के रूप में विभिन्न स्तरों पर संदेशों लॉग इन करने की अनुमति देता है

लेकिन मानक लॉगिंग एपीआई अतिरिक्त लाभ भी है। उदाहरण के लिए, FileHandler का उपयोग करके आप आसानी से लॉग फ़ाइल बना सकते हैं। वास्तव में, FileHandler में एक अंतर्निहित लॉग रोटेशन तंत्र है, इसलिए आपको लॉग फ़ाइलों को साफ करने के बारे में चिंता करने की आवश्यकता नहीं है (बहुत अधिक)। आप Logger एस का पदानुक्रम भी बना सकते हैं; इसलिए, उदाहरण के लिए, यदि आपके पास दो Logger एस हैं, com.example.foo और com.example.foo.bar, पूर्व के लॉगिंग स्तर को बदलने से बाद के लॉगिंग स्तर भी बदल जाएंगे। यह तब भी काम करेगा यदि विभिन्न 0 वर्गों में दो Logger एस बनाए गए हैं! इसके अलावा, आप लॉगिंग कॉन्फ़िगरेशन फ़ाइल निर्दिष्ट करके रनटाइम पर लॉगिंग व्यवहार बदलते हैं। अंत में, आप अपने स्वयं के Formatter को लागू करके लॉग के प्रारूप को कस्टमाइज़ कर सकते हैं (या डिफ़ॉल्ट XML प्रारूप से बचने के लिए बस SimpleFormatter का उपयोग करें)।

मानक लॉगिंग एपीआई का उपयोग करने के लिए आपको कुछ इस तरह की कोशिश कर सकते:

// Logger logger is an instance variable 
    // FileHandler logHandler is an instance variable 

    try { 
     String logDirectory = 
      Environment.getExternalStorageDirectory() + "/log_directory"; 

     // the %g is the number of the current log in the rotation 
     String logFileName = logDirectory + "/logfile_base_name_%g.log"; 

     // ... 
     // make sure that the log directory exists, or the next command will fail 
     // 

     // create a log file at the specified location that is capped 100kB. Keep up to 5 logs. 
     logHandler = new FileHandler(logFileName, 100 * 1024, 5); 
     // use a text-based format instead of the default XML-based format 
     logHandler.setFormatter(new SimpleFormatter()); 
     // get the actual Logger 
     logger = Logger.getLogger("com.example.foo"); 
     // Log to the file by associating the FileHandler with the log 
     logger.addHandler(logHandler); 
    } 
    catch (IOException ioe) { 
     // do something wise 
    } 

    // examples of using the logger 
    logger.finest("This message is only logged at the finest level (lowest/most-verbose level)"); 
    logger.config("This is an config-level message (middle level)"); 
    logger.severe("This is a severe-level message (highest/least-verbose level)"); 

एंड्रॉयड प्रवेश तंत्र निश्चित रूप से आसान और सुविधाजनक है। हालांकि, यह बहुत अनुकूलन योग्य नहीं है, और लॉग फ़िल्टरिंग टैग के साथ किया जाना चाहिए, जो आसानी से अनावश्यक हो सकता है।java.uitl.logging एपीआई का उपयोग करके, आप टैग की एक बड़ी संख्या से निपटने से बच सकते हैं, फिर भी लॉग फ़ाइल को अपने आवेदन के विशिष्ट हिस्सों में आसानी से सीमित कर सकते हैं, स्थान और उपस्थिति पर अधिक नियंत्रण प्राप्त कर सकते हैं, और रनटाइम पर लॉगिंग व्यवहार को भी अनुकूलित कर सकते हैं।

Answer 3

मैं यहां अपना उत्तर दोबारा पोस्ट करता हूं ताकि @ जेपीएम और अन्य देख सकें ... कोड मूल रूप से केवल logcat कमांड निष्पादित करता है और फिर इनपुट स्ट्रीम से लॉग बनाता है।

final StringBuilder log = new StringBuilder(); 
try {   
    ArrayList<String> commandLine = new ArrayList<String>(); 
    commandLine.add("logcat"); 
    commandLine.add("-d"); 
    ArrayList<String> arguments = ((params != null) && (params.length > 0)) ? params[0] : null; 
    if (null != arguments){ 
     commandLine.addAll(arguments); 
    } 

    Process process = Runtime.getRuntime().exec(commandLine.toArray(new String[0])); 
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream())); 

    String line; 
    while ((line = bufferedReader.readLine()) != null){ 
     log.append(line); 
     log.append(LINE_SEPARATOR); 
    } 
} 
catch (IOException e){ 
     // 
} 

return log; 

Answer 4

मैं जानता हूँ कि इस सवाल का एक देर से जवाब है, लेकिन मैं अत्यधिक एक लॉग फ़ाइल को संदेश के साथ-साथ logcat लिखने के Logback का उपयोग कर की सिफारिश करेंगे।

1. अपने libs फ़ोल्डर में logback-android-1.0.10-2.jar और slf4j-api-1.7.5.jar कॉपी करें।
2. दोनों libs और मेनू से राइट-क्लिक करें चुनें पथ -> बिल्ड पथ में जोड़ें।
3. अपनी संपत्ति फ़ोल्डर में एक logback.xml फ़ाइल बनाएँ और यह डालें:

    

    
    
    
     %msg 
    
    

    
    
    
     WARN 
    

    ${LOG_DIR}/log.txt 

    
     %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n 
     
    

    
    
    
    
    

1. एक लॉग लिखने के लिए:

   सार्वजनिक वर्ग MyActivity गतिविधि फैली { सार्वजनिक स्थिर अंतिम लॉगर लॉगर = LoggerFactory.getLogger (MyActivity.class);

   protected void onCreate(Bundle b) 
   { 
       super(b); 
       try{ 
        throw new Exception("Test"); 
       }catch(Exception e){ 
        logger.error("Something bad happened",e); 
       } 
   } 
   

   }