एंड्रॉइड राइटिंग लॉग टू टेक्स्ट फाइल


128

मैं इस कोड का उपयोग करके Android फ़ाइल पर कस्टम Log.txt फ़ाइल में लॉग लिखने की कोशिश कर रहा हूं, लेकिन फिर यह विधि फ़ाइल बनाती है, लेकिन इसमें कुछ भी नहीं है। मूल रूप से मैं फ़ाइल की पिछली सामग्री को पढ़ना चाहता हूं और फिर अपने डेटा को मौजूदा सामग्री के साथ जोड़ना चाहता हूं।

कोड इस प्रकार है:

public static void write(String str) 
    {
        InputStream fileInputStream = null;
        FileOutputStream fileOutpurStream = null;
        try
        { 
            fileInputStream = new FileInputStream(file);
            fileOutpurStream = new FileOutputStream(file);
            if(file.exists())
            {
                int ch = 0;
                int current = 0;
                StringBuffer buffer = new StringBuffer();
                while((ch = fileInputStream.read()) != -1)
                {
                    buffer.append((char) ch);
                    current++;
                }
                byte data[]=new byte[(int)file.length()];
                fileInputStream.read(data);   
                fileOutpurStream.write(data);
                fileOutpurStream.write(str.getBytes(),0,str.getBytes().length);
                fileOutpurStream.flush();
            } 
            else
            {   
                file.createNewFile();
                fileOutpurStream.write(str.getBytes(),0,str.getBytes().length);
                fileOutpurStream.flush();
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                fileInputStream.close();
                fileOutpurStream.flush();
                fileOutpurStream.close();
                fileOutpurStream = null;
                fileInputStream = null;
            }
            catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

जवाबों:


247

आशा है कि यह मदद कर सकता है ...

public void appendLog(String text)
{       
   File logFile = new File("sdcard/log.file");
   if (!logFile.exists())
   {
      try
      {
         logFile.createNewFile();
      } 
      catch (IOException e)
      {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   }
   try
   {
      //BufferedWriter for performance, true to set append to file flag
      BufferedWriter buf = new BufferedWriter(new FileWriter(logFile, true)); 
      buf.append(text);
      buf.newLine();
      buf.close();
   }
   catch (IOException e)
   {
      // TODO Auto-generated catch block
      e.printStackTrace();
   }
}

82
मेनिफेस्ट में writing_external_storage की अनुमति जोड़ना न भूलें!
virusss8

5
मुझे buf.flush () जोड़ने की आवश्यकता थी; beforebuf.close (); लेकिन tjis फंक्शन वही था जो मुझे चाहिए था। धन्यवाद
Csabi

1
मुझे इस फ़ंक्शन को कहां से कॉल करना चाहिए ताकि यह फ़ाइल में सभी एप्लिकेशन के लॉग को लिख सके ???
अनिरुद्ध

10
मैं कोड के पुनर्गठन की सिफारिश करूंगा ताकि यह buf.close()एक finallyब्लॉक के अंदर हो ।
विलियम प्राइस

2
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />क्या @ virusss8 का मतलब था, निश्चित रूप से।
बेंगट

29

सामान्य और Android लॉगिंग में जावा लॉगिंग करने वाले नए लोगों के लिए

  1. Log4j जेनेरिक जावा लॉगिंग कार्यान्वयन है और अब अपाचे सॉफ्टवेयर फाउंडेशन की एक परियोजना है। यह एंड्रॉइड विशिष्ट नहीं है और इसलिए एंड्रॉइड के साथ कुछ असंगतताएं हैं।
  2. SL4J एक लॉगिंग कार्यान्वयन नहीं है, यह एक अमूर्त परत है। यह इस तरह की स्थितियों से बचने में मदद करता है, जैसे कि परियोजना के लिए प्रत्येक 3 पार्टी लाइब्रेरी निर्भरता, लॉग 4j जैसे अपने लॉगिंग कार्यान्वयन का उपयोग करने की कोशिश कर रहा है। स्रोत

Android में txt पर लॉग इन करने के कुछ विकल्प नीचे दिए गए हैं

  1. फ़ाइल में लॉग इन करने के लिए logcat -fइस उत्तर के रूप में उपयोग करें । ध्यान दें कि एंड्रॉइड 4.2 से, READ_LOGS की अनुमति का कोई प्रभाव नहीं पड़ता है और हर एप्लिकेशन (जब तक कि फोन रूट नहीं होता है) केवल अपने लॉग को पढ़ सकता है। यहाँ नुकसान लॉगकैट बफर है, जो गोलाकार है और इसका आकार सीमा है। हो सकता है कि आपको पहले लॉग न मिले हों।
  2. पहले वाले उत्तर की तरह ही माइक्रोग्लॉफ़ंड्रोइड (एंड्रॉइड जैसे मोबाइल उपकरणों के लिए लिखित) का उपयोग करें । एक तरीका हो सकता है, लेकिन मैं यह नहीं समझ सका, कि आंतरिक भंडारण के लिए लॉगिंग के लिए माइक्रोलॉग 4 ऑन्ड्रोइड का उपयोग कैसे करें। लॉग पथ के लिए केवल विकल्प sdcard की तरह बाहरी भंडारण था और इसलिए मैं इसका उपयोग नहीं कर सका।
  3. Log4j का उपयोग android-logging-log4j के साथ करें । Android-logging-log4j क्या करता है? यह दो कार्य देकर Android में Log4j का उपयोग करना आसान बनाता है।

    • लॉगिंग फ़ाइल के अतिरिक्त लॉग लॉग में भेजने का विकल्प
    • LogConfigatorator वर्ग प्रदान करके Log4j कॉन्फ़िगरेशन विकल्प जैसे फ़ाइल पथ, अधिकतम फ़ाइल आकार, बैकअप की संख्या आदि को सेट करने का एक सरल तरीका।

    नीचे सरल उदाहरण है। ध्यान दें कि loggerनीचे दिए गए उदाहरण में ऑब्जेक्ट एक Log4j ऑब्जेक्ट लौटाया गया है न कि एक एंड्रॉइड-लॉगिंग-लॉग 4 जे क्लास। तो android-logging-log4j का उपयोग केवल Log4j को कॉन्फ़िगर करने के लिए किया जाता है।

  4. फिर भी लॉगबैक की कोशिश करना । LogBack को उसी व्यक्ति द्वारा विकसित किया गया है जो Log4J 1.x और SL4J पुस्तकालयों के साथ आया था। हालांकि Log4j 2.x से संबंधित नहीं है।

Android में Log4j का उपयोग करने के लिए चरण।

  1. Lib4 फ़ोल्डर में log4j-1.2.x.jar और android-logging-log4j-1.0.3.jar दोनों को जोड़ें ।

  2. केवल बाह्य संग्रहण का उपयोग करते समय अनुमतियाँ जोड़ें
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

  3. Log4jसहायक वर्ग लिखें

    package com.example.logger;
    
    import android.os.Environment;
    import de.mindpipe.android.logging.log4j.LogConfigurator;
    
    public class Log4jHelper {
        private final static LogConfigurator mLogConfigrator = new LogConfigurator();
    
        static {
            configureLog4j();
        }
    
        private static void configureLog4j() {
            String fileName = Environment.getExternalStorageDirectory() + "/" + "log4j.log";
            String filePattern = "%d - [%c] - %p : %m%n";
            int maxBackupSize = 10;
            long maxFileSize = 1024 * 1024;
    
            configure( fileName, filePattern, maxBackupSize, maxFileSize );
        }
    
        private static void configure( String fileName, String filePattern, int maxBackupSize, long maxFileSize ) {
            mLogConfigrator.setFileName( fileName );
            mLogConfigrator.setMaxFileSize( maxFileSize );
            mLogConfigrator.setFilePattern(filePattern);
            mLogConfigrator.setMaxBackupSize(maxBackupSize);
            mLogConfigrator.setUseLogCatAppender(true);
            mLogConfigrator.configure();
    
        }
    
        public static org.apache.log4j.Logger getLogger( String name ) {
            org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger( name );
            return logger;
        }
    }
  4. गतिविधि वर्ग में

    org.apache.log4j.Logger log= Log4jHelper.getLogger( "YourActivity" );
    log.error("Error");
    log.info("Info");
    log.warn("Warn");

उदाहरण स्रोत । ध्यान दें कि, log4j 2.x (बेहतर फंक्शनालिटीज) जो स्क्रैच से दोबारा लिखा गया है, log4j 1.x. तो आपको android-logging-log4j जार के साथ log4j 1.2.x जार का उपयोग करना होगा। मैं एप्लिकेशन आंतरिक फ़ाइल में लॉग इन करने में सक्षम था और बाद में फ़ाइल को ईमेल करता थाsetReadable(true, false)


24

microlog4android मेरे लिए काम करता है लेकिन प्रलेखन बहुत खराब है। वे सभी जोड़ने की जरूरत है यह एक त्वरित शुरुआत ट्यूटोरियल है

यहाँ एक त्वरित ट्यूटोरियल है जो मुझे मिला।

  1. अपनी मुख्य गतिविधि में निम्नलिखित स्थिर चर जोड़ें:

    private static final Logger logger = LoggerFactory.getLogger();
  2. अपनी onCreate()विधि में निम्नलिखित जोड़ें :

    PropertyConfigurator.getConfigurator(this).configure();
  3. नाम से एक फ़ाइल बनाएं microlog.propertiesऔर इसे assetsनिर्देशिका में संग्रहीत करें

  4. microlog.propertiesफाइल को निम्नानुसार संपादित करें :

    microlog.level=DEBUG
    microlog.appender=LogCatAppender;FileAppender
    microlog.formatter=PatternFormatter
    microlog.formatter.PatternFormatter.pattern=%c [%P] %m %T
  5. इस तरह लॉगिंग स्टेटमेंट जोड़ें:

    logger.debug("M4A");

प्रत्येक वर्ग के लिए आप 1 में निर्दिष्ट के रूप में एक लकड़हारा वस्तु बनाते हैं)

6. आप निम्नलिखित अनुमति जोड़ सकते हैं:

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

यहाँ ट्यूटोरियल के लिए स्रोत है


4
FileAppender आपके sdcard पर एक फ़ाइल "microlog.txt" बनाएगा (मेरे मामले में पूरा रास्ता "/sdcard/microlog.txt) है।
रुस्लान यानचिश्यन

2
यह त्वरित ट्यूटोरियल Microlog4Android आधिकारिक दस्तावेज का हिस्सा होना चाहिए।
जोहान कार्लसन ने

त्रुटि: Android डेक्स: [प्रोजेक्ट] com.android.dex.DexException: एकाधिक डेक्स फाइलें Lcom / google / code / microlog4android / Level को परिभाषित करती हैं; ?

10

चेतावनी: मैं आपको पूरी तरह से गलत समझ सकता हूं, लेकिन अगर आप चाहते हैं कि एक लॉग फ़ाइल है, तो पसीना क्यों?

इसे एक बैट फ़ाइल में रखें (अपने टूल डायरेक्टरी में पथ बदलें, और yourappname आपके ऐप के नाम का है):

cd "C:\devAndroid\Software\android-sdk-windows-1.6_r1\android-sdk-windows-1.6_r1\tools"
adb logcat -v time   ActivityManager:W  yourappname:D  *:W >"C:\devAndroid\log\yourappname.log"

फिर आपके कोड में बस इसी तरह से कुछ करना है:

Log.d("yourappname", "Your message");

लॉग बनाने के लिए, यूएसबी केबल कनेक्ट करें और अपनी बैट फाइल चलाएं।

सादर


Android.util.Log आयात करना न भूलें।
Spidey

यह "त्रुटि: एक से अधिक डिवाइस और एमुलेटर - डिवाइस की प्रतीक्षा कर रहा है" और कुछ भी नहीं देता है। कुछ गड़बड़ है क्या?
एरोस

20
यदि आप एप्लिकेशन चलाते समय पीसी के पास नहीं हैं तो यह कैसे काम करता है?
DDSports

@DDSports यह नहीं करता है। लेकिन उन्होंने सवाल का सार नहीं समझा
Ewoks

@ डीडीस्पोर्ट्स आप वाईफ़ाई पर एडीबी का उपयोग कर सकते हैं।
डैनियल एफ

8

Slf4android lib का उपयोग करें ।
यह एंड्रॉइड java.util.log * का उपयोग करके slf4j एपीआई का सरल कार्यान्वयन है । *।

विशेषताएं:

  • बॉक्स से बाहर फाइल करने के लिए लॉगिंग
  • किसी अन्य गंतव्य पर प्रवेश करना LoggerConfiguration.configuration().addHandlerToLogger
  • ईमेल के माध्यम से स्क्रीनशॉट के साथ लॉग भेजने के लिए अपने डिवाइस को हिलाएं
  • वास्तव में छोटा है, यह केवल ~ 55kB लेता है

slf4android मुख्य रूप से @miensol द्वारा बनाए रखा जाता है ।

हमारे ब्लॉग पर slf4android के बारे में और पढ़ें:


7

आपको microlog4android पर एक नज़र डालनी चाहिए। उनके पास फ़ाइल में लॉग इन करने के लिए एक समाधान तैयार है।

http://code.google.com/p/microlog4android/


12
यह एक अच्छी लाइब्रेरी की तरह लगता है, लेकिन प्रलेखन बहुत ही भयानक है। मैं बस यह पता नहीं लगा सका कि इसे काम करने के लिए कैसे लाया जाए और खुद को एक साथ रखने के लिए समाप्त किया जाए।
पॉल लामर्ट्स्मा

@PaulLammertsma: मुझे लगता है कि यह अच्छा होगा कि आपने इसके स्थान पर Microlog4Android में योगदान दिया। FYI करें: इसमें लॉग 4j के समान ही एपीआई है। खराब दस्तावेज के बारे में क्षमा करें।
जोहान कर्ल्ससन

@Paul Lammertsma कुछ भी अच्छा कैसे हो सकता है अगर यह प्रलेखन है कि बुरा आप इसका उपयोग नहीं कर सकते हैं? यदि आप इसे बकवास करने के लिए काम नहीं कर सकते हैं।
7 जनवरी को अविश्वसनीय जनवरी

7

यह देर हो सकती है लेकिन उम्मीद है कि यह मदद कर सकता है .. यह कोशिश करो ...।

public void writefile()
    {
        File externalStorageDir = Environment.getExternalStorageDirectory();
        File myFile = new File(externalStorageDir , "yourfilename.txt");

        if(myFile.exists())
        {
           try
           {

        FileOutputStream fostream = new FileOutputStream(myFile);
        OutputStreamWriter oswriter = new OutputStreamWriter(fostream); 
        BufferedWriter bwriter = new BufferedWriter(oswriter);   
        bwriter.write("Hi welcome ");
        bwriter.newLine();            
        bwriter.close(); 
        oswriter.close(); 
        fostream.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
        else
        {
            try {
                myFile.createNewFile();
            }
            catch (IOException e) 
            {
                e.printStackTrace();
            }
        }

यहाँ bfwritter.newlineफ़ाइल में अपना पाठ लिखते हैं। और अनुमति जोड़ें

 <uses-permission android:name = "android.permission.WRITE_EXTERNAL_STORAGE"/>

आपकी मेनिफ़ेस्ट फ़ाइल में बिना विफल हुए।


6

मैंने कमांड लाइन तरीके से निम्नलिखित समस्या को हल किया है:

File outputFile = new File("pathToFile"); 
Runtime.getRuntime().exec("logcat -c");
Runtime.getRuntime().exec("logcat -v time -f " + outputFile.getAbsolutePath())

जहां "समय" विकल्प तिथि, मंगलाचरण समय, प्राथमिकता / टैग और संदेश जारी करने की प्रक्रिया के पीआईडी ​​के लिए मेटाडेटा फ़ील्ड विवरण जोड़ता है।

फिर अपने कोड में बस कुछ ऐसा ही करें (android.util.Log का उपयोग करके):

Log.d("yourappname", "Your message");

4
adbकनेक्ट होने पर अच्छी तरह से काम करता है, लेकिन जब डिवाइस स्टैंडअलोन मोड में होता है तो काम नहीं करता है। मैं इसे उत्पादन में उपयोग नहीं करूंगा, लेकिन यह डिबग मोड में एक सरल उपाय है।
जुलिएन क्रोनगैस

2

सामान्य तौर पर, स्ट्रीम खोलने से पहले आपके पास एक फ़ाइल हैंडल होना चाहिए। आपके पास दूसरे ब्लॉक में createNewFile () से पहले एक fileOutputStream हैंडल है । यदि यह मौजूद नहीं है तो स्ट्रीम फ़ाइल नहीं बनाता है।

वास्तव में एंड्रॉइड विशिष्ट नहीं है, लेकिन इस उद्देश्य के लिए बहुत अधिक आईओ है। यदि आप एक के बाद एक कई "राइट" ऑपरेशन करते हैं तो क्या होगा? आप पूरी सामग्री पढ़ रहे होंगे और पूरी सामग्री लिख रहे होंगे, समय ले रहे होंगे, और इससे भी महत्वपूर्ण बात, बैटरी जीवन।

मेरा सुझाव है कि java.io.RandomAccessFile का उपयोग करते हुए, अंत तक () 'आईएनजी, फिर राइटर्स () को जोड़ें। यह बहुत क्लीनर कोड होगा और बहुत तेजी से होने की संभावना है।


2

मैंने एक सरल, हल्के वर्ग (लगभग 260 एलओसी) का निर्माण किया है जो मानक android.util का विस्तार करता है। फ़ाइल आधारित लॉगिंग के साथ कार्यान्वयन।
हर लॉग संदेश android.util.Log के माध्यम से लॉग किया जाता है और डिवाइस पर एक पाठ फ़ाइल में भी लिखा जाता है।

आप इसे जीथब पर पा सकते हैं:
https://github.com/volkerv/FileLog


1
आप बात नहीं करते कि हमें यह सुनिश्चित करने की आवश्यकता है कि यूआई थ्रेड पर फ़ाइल संचालन नहीं किया जाता है। Incase हमारे पास भारी मात्रा में फ़ाइल लॉगिंग है?
जयशिल दवे

2

लंबे समय तक जांच के बाद मैंने पाया कि:

  • android.util.Log डिफ़ॉल्ट रूप से उपयोग java.util.logging.Logger
  • LogCat loggerनाम के साथ उपयोग करता है "", इसका उपयोग प्राप्त करने के लिएLogManager.getLogManager().getLogger("")
  • डीबग ऐप्स चलाने के बाद Android डिवाइस LogCat loggerइंस्टेंस में जुड़ जाता हैcom.android.internal.logging.AndroidHandler
  • परंतु!!! com.android.internal.logging.AndroidHandlerसंदेशों को केवल अधिक स्तरों के साथ लॉगकट करने के लिए प्रिंट java.util.logging.Level.INFOकरता है जैसे ( Level.INFO, Level.WARNING, Level.SEVERE, Level.OFF)

इतना सरल करने के लिए लॉग फाइल करने के लिए लिखने के लिए rootLogger "" जोड़ने के लिए java.util.logging.FileHandler:

  class App : Application{
    override fun onCreate() {
      super.onCreate()
      Log.d(TAG, printLoggers("before setup"))

      val rootLogger = java.util.logging.LogManager.getLogManager().getLogger("")
      val dirFile = destinationFolder
      val file = File(dirFile,"logFile.txt")
      val handler = java.util.logging.FileHandler(file.absolutePath, 5* 1024 * 1024/*5Mb*/, 1, true)
      handler.formatter = AndroidLogFormatter(filePath = file.absolutePath)

      rootLogger?.addHandler(handler)

      Log.d(TAG, printLoggers("after setup"))
    }
  }

val destinationFolder: File
        get() {
            val parent = 
                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).absoluteFile
            val destinationFolder = File(parent, "MyApp")
            if (!destinationFolder.exists()) {
                destinationFolder.mkdirs()
                destinationFolder.mkdir()
            }
            return destinationFolder
        }
class AndroidLogFormatter(val filePath: String = "", var tagPrefix: String = "") : Formatter() {

    override fun format(record: LogRecord): String {
        val tag = record.getTag(tagPrefix)
        val date = record.getDate()
        val level = record.getLogCatLevel()
        val message = record.getLogCatMessage()
        return "$date $level$tag: $message\n"
    }
}

fun LogRecord.getTag(tagPrefix: String): String {
    val name = loggerName
    val maxLength = 30
    val tag = tagPrefix + (if (name.length > maxLength) name.substring(name.length - maxLength) else name)
    return tag
}

fun LogRecord.getDate(): String? {
    return Date(millis).formatedBy("yyyy-MM-dd HH:mm:ss.SSS")
}

fun Date?.formatedBy(dateFormat: String): String? {
    val date = this
    date ?: return null
    val writeFormat = SimpleDateFormat(dateFormat, Locale.getDefault()) //MM в HH:mm
    return writeFormat.format(date)
}

fun LogRecord.getLogCatMessage(): String {
    var message = message

    if (thrown != null) {
        message += Log.getStackTraceString(thrown)
    }
    return message
}

fun Int.getAndroidLevel(): Int {
    return when {
        this >= Level.SEVERE.intValue() -> { // SEVERE
            Log.ERROR
        }
        this >= Level.WARNING.intValue() -> { // WARNING
            Log.WARN
        }
        this >= Level.INFO.intValue() -> { // INFO
            Log.INFO
        }
        else -> {
            Log.DEBUG
        }
    }
}

fun LogRecord.getLogCatLevel(): String {
    return when (level.intValue().getAndroidLevel()) {
        Log.ERROR -> { // SEVERE
            "E/"
        }
        Log.WARN -> { // WARNING
            "W/"
        }
        Log.INFO -> { // INFO
            "I/"
        }
        Log.DEBUG -> {
            "D/"
        }
        else -> {
            "D/"
        }
    }
}

fun getLoggerLevel(level: Int): Level {
    return when (level) {
        Log.ERROR -> { // SEVERE
            Level.SEVERE
        }
        Log.WARN -> { // WARNING
            Level.WARNING
        }
        Log.INFO -> { // INFO
            Level.INFO
        }
        Log.DEBUG -> {
            Level.FINE
        }
        else -> {
            Level.FINEST
        }
    }
}

अपने एप्लिकेशन के उपयोग पर सभी लॉगर्स को प्रिंट करने के लिए:

Log.e(TAG, printLoggers("before setup"))

 private fun printLoggers(caller: String, printIfEmpty: Boolean = true): String {
        val builder = StringBuilder()
        val loggerNames = LogManager.getLogManager().loggerNames
        builder.appendln("--------------------------------------------------------------")
        builder.appendln("printLoggers: $caller")
        while (loggerNames.hasMoreElements()) {
            val element = loggerNames.nextElement()
            val logger = LogManager.getLogManager().getLogger(element)
            val parentLogger: Logger? = logger.parent
            val handlers = logger.handlers
            val level = logger?.level
            if (!printIfEmpty && handlers.isEmpty()) {
                continue
            }
            val handlersNames = handlers.map {
                val handlerName = it.javaClass.simpleName
                val formatter: Formatter? = it.formatter
                val formatterName = if (formatter is AndroidLogFormatter) {
                    "${formatter.javaClass.simpleName}(${formatter.filePath})"
                } else {
                    formatter?.javaClass?.simpleName
                }
                "$handlerName($formatterName)"
            }
            builder.appendln("level: $level logger: \"$element\" handlers: $handlersNames parentLogger: ${parentLogger?.name}")
        }
        builder.appendln("--------------------------------------------------------------")
        return builder.toString()
    }

नमस्ते। इस लकड़हारे का उपयोग करने से क्या लाभ है। मैं एक कस्टम लकड़हारे के साथ कोई अंतर नहीं देखता। या क्या मैं कुछ न कुछ भूल रहा हूं ?
शाजी जूल

1

यह संस्करण बहुत छोटा है

प्रयत्न {
    अंतिम फ़ाइल पथ = नई फ़ाइल (
            एनवायरनमेंट .getExternalStorageDirectory (), "DBO_logs5");
    अगर (पाथ.एक्सिस्टर्स ()) {
        path.mkdir ();
    }
    Runtime.getRuntime ()। कार्यकारी (
            "logcat -d -f" + path + File.separator
                    + "dbo_logcat"
                    + ".txt");
} कैच (IOException e) {
    e.printStackTrace ();
}

1

मेरे द्वारा लिखी गई लाइब्रेरी का उपयोग कर सकते हैं। इसका उपयोग करना बहुत आसान है:

अपनी निर्भरता फ़ाइल में इस निर्भरता को जोड़ें:

dependencies {
    compile 'com.github.danylovolokh:android-logger:1.0.2'
}

अनुप्रयोग वर्ग में लाइब्रेरी को प्रारंभ करें:

File logsDirectory = AndroidLogger.getDefaultLogFilesDirectory(this);
    int logFileMaxSizeBytes = 2 * 1024 * 1024; // 2Mb
    try {
        AndroidLogger.initialize(
                this,
                logsDirectory,
                "Log_File_Name",
                logFileMaxSizeBytes,
                false
                );
    } catch (IOException e) {
        // Some error happened - most likely there is no free space on the system
    }

यह है कि आप पुस्तकालय का उपयोग कैसे करते हैं:

AndroidLogger.v("TAG", "Verbose Message");

और यह कैसे लॉग को पुनः प्राप्त करने के लिए है:

AndroidLogger.processPendingLogsStopAndGetLogFiles(new AndroidLogger.GetFilesCallback() {
        @Override
        public void onFiles(File[] logFiles) {
            // get everything you need from these files
            try {
                AndroidLogger.reinitAndroidLogger();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    });

यहाँ अधिक जानकारी के साथ github पृष्ठ का लिंक दिया गया है: https://github.com/danylovolokh/AndroidLogger

आशा करता हूँ की ये काम करेगा।


1

Log4j पर पिछले संस्करणों में से कई अब काम नहीं करते (05/2019)। लेकिन आप हाइपरलॉग का उपयोग कर सकते हैं - मैं इसकी पुष्टि करता हूं कि यह काम करता है।

  1. इस लाइन को अपनी निर्भरता और सिंक प्रोजेक्ट में जोड़ें

    implementation 'com.hypertrack:hyperlog:0.0.10'
  2. एक नया एप्लिकेशन क्लास बनाएं (एक नया जावा क्लास बनाएं और एप्लिकेशन का विस्तार करें)। फिर ऑनक्रैट विधि में इन पंक्तियों को जोड़ें:

    HyperLog.initialize(this);
    HyperLog.setLogLevel(Log.VERBOSE);
    
    HyperLog.getDeviceLogsInFile(this);
  3. एप्लिकेशन फ़ाइल परिभाषित करने के लिए प्रकट फ़ाइल बदलें।

    <application
        android:name=".AppClass"
        .....
  4. लॉग करने के विभिन्न तरीके:

    HyperLog.d(TAG,"debug");
    HyperLog.i(TAG,"information");
    HyperLog.e(TAG,"error");
    HyperLog.v(TAG,"verbose");
    HyperLog.w(TAG,"warning");
    HyperLog.a(TAG,"assert");
    HyperLog.exception(TAG,"exception",throwable);
  5. अपनी लॉग फाइलें खोजें। पर जाए

    RootFolder/android/data/"appPackageName/LogFiles/

हाइपरलॉग .getDeviceLogsInFile (यह) के साथ उत्पन्न फ़ाइल में मैंने इस लाइब्रेरी की कोशिश की; केवल अंतिम उत्पन्न लॉग वहाँ है
mad_greasemonkey
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.