精华内容
下载资源
问答
  • 2021-06-04 07:14:26

    private boolean writeToSDCard(Throwable ex)

    {

    boolean isDealing = false;

    if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED))

    {

    RandomAccessFile randomAccessFile = null;

    try

    {

    String fileName = SDCARDROOT + File.separator + "logs" + File.separator + "crash" + File.separator;

    File file = new File(fileName);

    if(!file.exists())

    file.mkdirs();

    randomAccessFile = new RandomAccessFile(fileName + paserTime(System.currentTimeMillis())+ ".log", "rw");

    long fileLength = randomAccessFile.length();

    randomAccessFile.seek(fileLength);

    randomAccessFile.writeBytes(getThrowableInfo(ex));

    }

    catch (IOException e)

    {

    e.printStackTrace();

    }

    finally

    {

    if (randomAccessFile != null)

    {

    try

    {

    randomAccessFile.close();

    isDealing = true;

    }

    catch (IOException e)

    {

    e.printStackTrace();

    }

    }

    }

    }

    return isDealing;

    }

    private static String getThrowableInfo(Throwable ex)

    {

    StringWriter stringWriter = new StringWriter();

    PrintWriter printWriter = new PrintWriter(stringWriter);

    ex.printStackTrace(printWriter);

    return stringWriter.toString();

    }

    原文:http://blog.csdn.net/wangyuexing_blog/article/details/34799671

    更多相关内容
  • 1. 创建类继承 UncaughtExceptionHandlerimport android.content.Context;import android.os.Environment;import android.os.Looper;import android.text.TextUtils;import android.util.Log;import android.widget....

    1. 创建类继承 UncaughtExceptionHandler

    import android.content.Context;

    import android.os.Environment;

    import android.os.Looper;

    import android.text.TextUtils;

    import android.util.Log;

    import android.widget.Toast;

    import com.emh.pdavoicecall4.constant.Constants;

    import java.io.ByteArrayInputStream;

    import java.io.File;

    import java.io.FileOutputStream;

    import java.io.IOException;

    import java.io.PrintWriter;

    import java.io.StringWriter;

    import java.io.Writer;

    import java.text.SimpleDateFormat;

    import java.util.ArrayList;

    import java.util.Date;

    import java.util.List;

    import java.util.Locale;

    import androidx.annotation.NonNull;

    public class MyCrashHandler implements Thread.UncaughtExceptionHandler {

    private Context context;

    private static final String APP_NAME = Constants.APP_PACKAGE_NAME;

    private String logFilePath = Environment.getExternalStorageDirectory().getPath()

    + File.separator + APP_NAME + File.separator + "Log" + File.separator + "crashlog";

    public MyCrashHandler(Context context) {

    this.context = context;

    }

    @Override

    public void uncaughtException(@NonNull Thread thread, @NonNull final Throwable ex) {

    Log.e("程序出现异常", "Thread = " + thread.getName() + "\nThrowable = " + ex.getMessage());

    String stackTraceInfo = getStackTraceInfo(ex);

    Log.e("stackTraceInfo", stackTraceInfo);

    saveThrowableMessage(stackTraceInfo);

    new Thread() {

    public void run() {

    Looper.prepare();

    Toast.makeText(context, ex.getMessage(), Toast.LENGTH_SHORT).show();

    Looper.loop();

    };

    }.start();

    }

    private String getStackTraceInfo(final Throwable t) {

    PrintWriter pw = null;

    Writer writer = new StringWriter();

    try {

    pw = new PrintWriter(writer);

    t.printStackTrace(pw);

    } catch (Exception e) {

    return "";

    } finally {

    if (pw != null) {

    pw.close();

    }

    }

    return writer.toString();

    }

    private void saveThrowableMessage(String errorMessage) {

    if (TextUtils.isEmpty(errorMessage)) {

    return;

    }

    File file = new File(logFilePath);

    if (!file.exists()) {

    boolean mkdirs = file.mkdirs();

    if (mkdirs) {

    writeStringToFile(errorMessage, file);

    }

    } else {

    writeStringToFile(errorMessage, file);

    }

    }

    private void writeStringToFile(final String errorMessage, final File file) {

    FileOutputStream fos = null;

    try {

    String content = errorMessage + "[" + Utils.getCurrentDateTime() + "]\r\n";

    ByteArrayInputStream bais = new ByteArrayInputStream(content.getBytes("UTF-8"));

    File crashLog = createCrashLogFile(file);

    fos = new FileOutputStream(crashLog, true);

    int len = 0;

    byte[] bytes = new byte[1024];

    while ((len = bais.read(bytes)) != -1) {

    fos.write(bytes, 0, len);

    }

    fos.flush();

    Log.e("程序出现异常", "写入本地文件成功:" + file.getAbsolutePath());

    } catch (Exception e) {

    e.printStackTrace();

    } finally {

    if (fos != null) {

    try {

    fos.close();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

    private List getAllCrashFiles() {

    File dir = new File(logFilePath);

    File[] files = dir.listFiles();

    List fileNames = new ArrayList<>();

    for (int i = 0; i < files.length; i++) {

    if (files[i].isFile()) {

    fileNames.add(files[i].getName());

    }

    }

    return fileNames;

    }

    private File createCrashLogFile(File file) throws IOException {

    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd", Locale.CHINA);

    String currentDate = sdf.format(new Date());

    File crashLog = new File(file, currentDate + ".txt");

    if (!crashLog.exists()) {

    crashLog.createNewFile();

    List crashLogNames = getAllCrashFiles();

    if (crashLogNames.size() > 10) {

    long currentTimeMilSeconds = new Date().getTime();

    String earliestDate = sdf.format(new Date(currentTimeMilSeconds - 24 * 60 * 60 * 10 * 1000));

    deleteFile(earliestDate + ".txt");

    }

    }

    return crashLog;

    }

    private void deleteFile(String fileName) {

    File file = new File(logFilePath + File.separator + fileName);

    if (file.exists()) {

    file.delete();

    }

    }

    }

    2. 创建类继承Application,初始化MyCrashHandler

    import android.app.Application;

    public class MyApp extends Application {

    @Override

    public void onCreate() {

    // TODO Auto-generated method stub

    super.onCreate();

    MyCrashHandler handler = new MyCrashHandler(getApplicationContext());

    Thread.setDefaultUncaughtExceptionHandler(handler);

    }

    }

    3. 测试

    import android.app.Activity;

    import android.os.Bundle;

    import android.view.View;

    import android.view.View.OnClickListener;

    import android.widget.Button;

    public class MainActivity extends Activity {

    private Button test_crash_btn;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

    // TODO Auto-generated method stub

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

    test_crash_btn = (Button) findViewById(R.id.test_crash_btn);

    test_crash_btn.setOnClickListener(new OnClickListener() {

    @Override

    public void onClick(View v) {

    testThreadException();

    }

    });

    }

    private void testUIThreadException() {

    String string = null;

    char[] chars = string.toCharArray();

    }

    private void testThreadException() {

    Thread thread = new Thread(new Runnable() {

    @Override

    public void run() {

    int i = 0;

    int s = 10 / i;

    }

    });

    thread.start();

    }

    }

    展开全文
  • /** * 捕获android程序崩溃日志 * UncaughtException处理类,当程序发生Uncaught异常的时候,有该类来接管程序. * * @author PMTOAM * */ @SuppressLint("SimpleDateFormat") public class CrashHandler implements ...

    主要类:

    package com.example.callstatus;

    import java.io.File;

    import java.io.FileOutputStream;

    import java.io.PrintWriter;

    import java.io.StringWriter;

    import java.lang.Thread.UncaughtExceptionHandler;

    import java.lang.reflect.Field;

    import java.net.UnknownHostException;

    import java.text.DateFormat;

    import java.text.SimpleDateFormat;

    import java.util.Date;

    import java.util.HashMap;

    import java.util.Map;

    import android.annotation.SuppressLint;

    import android.content.Context;

    import android.content.pm.PackageInfo;

    import android.content.pm.PackageManager;

    import android.content.pm.PackageManager.NameNotFoundException;

    import android.os.Build;

    import android.os.Environment;

    import android.os.Looper;

    import android.telephony.TelephonyManager;

    import android.text.TextUtils;

    import android.util.Log;

    import android.widget.Toast;

    /**

    * 捕获android程序崩溃日志

    * UncaughtException处理类,当程序发生Uncaught异常的时候,有该类来接管程序.

    *

    * @author PMTOAM

    *

    */

    @SuppressLint("SimpleDateFormat")

    public class CrashHandler implements UncaughtExceptionHandler

    {

    public static final String TAG = CrashHandler.class.getCanonicalName();

    // 系统默认的UncaughtException处理类

    private Thread.UncaughtExceptionHandler mDefaultHandler;

    // CrashHandler实例

    private static CrashHandler INSTANCE = new CrashHandler();

    // 程序的Context对象

    private Context mContext;

    // 用来存储设备信息和异常信息

    private Map infos = new HashMap();

    // 用于格式化日期,作为日志文件名的一部分

    private DateFormat formatter = new SimpleDateFormat("yyyyMMdd_HHmmss");

    /**

    * 保证只有一个实例

    */

    private CrashHandler()

    {

    }

    /**

    * 获取实例 ,单例模式

    */

    public static CrashHandler getInstance()

    {

    return INSTANCE;

    }

    /**

    * 初始化

    *

    * @param context

    */

    public void init(Context context)

    {

    mContext = context;

    // 获取系统默认的UncaughtException处理器

    mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();

    // 设置该CrashHandler为程序的默认处理器

    Thread.setDefaultUncaughtExceptionHandler(this);

    }

    /**

    * 当UncaughtException发生时会转入该函数来处理

    */

    @Override

    public void uncaughtException(Thread thread, Throwable ex)

    {

    if (!handleException(ex) && mDefaultHandler != null)

    {

    // 如果用户没有处理则让系统默认的异常处理器来处理

    mDefaultHandler.uncaughtException(thread, ex);

    }

    else

    {

    try

    {

    Thread.sleep(3000);

    }

    catch (InterruptedException e)

    {

    Log.e(TAG, "error : ", e);

    }

    // 退出程序

    android.os.Process.killProcess(android.os.Process.myPid());

    System.exit(1);

    }

    }

    /**

    * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.

    *

    * @param ex

    * @return true:如果处理了该异常信息;否则返回false.

    */

    private boolean handleException(Throwable ex)

    {

    if (ex == null)

    {

    return false;

    }

    // 使用Toast来显示异常信息

    new Thread()

    {

    @Override

    public void run()

    {

    Looper.prepare();

    Toast.makeText(mContext, "很抱歉,程序出现异常。", Toast.LENGTH_LONG)

    .show();

    Looper.loop();

    }

    }.start();

    // 收集设备参数信息

    collectDeviceInfo(mContext);

    // 保存日志文件

    String str = saveCrashInfo2File(ex);

    Log.e(TAG, str);

    return false;

    }

    /**

    * 收集设备参数信息

    *

    * @param ctx

    */

    public void collectDeviceInfo(Context ctx)

    {

    try

    {

    PackageManager pm = ctx.getPackageManager();

    PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(),

    PackageManager.GET_ACTIVITIES);

    if (pi != null)

    {

    String versionName = pi.versionName == null ? "null"

    : pi.versionName;

    String versionCode = pi.versionCode + "";

    infos.put("versionName", versionName);

    infos.put("versionCode", versionCode);

    }

    }

    catch (NameNotFoundException e)

    {

    Log.e(TAG, "an error occured when collect package info", e);

    }

    Field[] fields = Build.class.getDeclaredFields();

    for (Field field : fields)

    {

    try

    {

    field.setAccessible(true);

    infos.put(field.getName(), field.get(null).toString());

    Log.d(TAG, field.getName() + " : " + field.get(null));

    }

    catch (Exception e)

    {

    Log.e(TAG, "an error occured when collect crash info", e);

    }

    }

    }

    /**

    * 保存错误信息到文件中

    *

    * @param ex

    * @return 返回文件名称,便于将文件传送到服务器

    */

    private String saveCrashInfo2File(Throwable ex)

    {

    StringBuffer sb = new StringBuffer();

    for (Map.Entry entry : infos.entrySet())

    {

    String key = entry.getKey();

    String value = entry.getValue();

    sb.append("[" + key + ", " + value + "]\n");

    }

    sb.append("\n" + getStackTraceString(ex));

    try

    {

    String time = formatter.format(new Date());

    TelephonyManager mTelephonyMgr = (TelephonyManager) mContext

    .getSystemService(Context.TELEPHONY_SERVICE);

    String imei = mTelephonyMgr.getDeviceId();

    if (TextUtils.isEmpty(imei))

    {

    imei = "unknownimei";

    }

    String fileName = "CRS_" + time + "_" + imei + ".txt";

    File sdDir = null;

    if (Environment.getExternalStorageState().equals(

    android.os.Environment.MEDIA_MOUNTED))

    sdDir = Environment.getExternalStorageDirectory();

    File cacheDir = new File(sdDir + File.separator + "dPhoneLog");

    if (!cacheDir.exists())

    cacheDir.mkdir();

    File filePath = new File(cacheDir + File.separator + fileName);

    FileOutputStream fos = new FileOutputStream(filePath);

    fos.write(sb.toString().getBytes());

    fos.close();

    return fileName;

    }

    catch (Exception e)

    {

    Log.e(TAG, "an error occured while writing file...", e);

    }

    return null;

    }

    /**

    * 获取捕捉到的异常的字符串

    */

    public static String getStackTraceString(Throwable tr)

    {

    if (tr == null)

    {

    return "";

    }

    Throwable t = tr;

    while (t != null)

    {

    if (t instanceof UnknownHostException)

    {

    return "";

    }

    t = t.getCause();

    }

    StringWriter sw = new StringWriter();

    PrintWriter pw = new PrintWriter(sw);

    tr.printStackTrace(pw);

    return sw.toString();

    }

    }

    使用方法:

    package com.example.callstatus;

    import android.app.Application;

    public class MyApplication extends Application

    {

    @Override

    public void onCreate()

    {

    super.onCreate();

    CrashHandler crashHandler = CrashHandler.getInstance();

    crashHandler.init(getApplicationContext());

    }

    }

    所需权限:

    原文:http://blog.csdn.net/wangyuexing_blog/article/details/39009069

    展开全文
  • Android收集程序崩溃日志

    万次阅读 多人点赞 2018-08-30 17:21:08
    我们都知道我们的android程序是跑在UI线程中的,而且我们会在程序中创建各种子线程。为了统一,如果我们给每个线程都通过 setUncaughtExceptionHandler() 这个方法来设置 UncaughtExceptionHandler 的话,未免太不...

    开个头

    程序崩溃是我们开发人员最不想看到的,但也是我们不可避免的。在我们开发阶段,当程序发生崩溃的时候,我们需要根据打印的错误日志来定位,分析,解决错误。但是当我们把应用发布到应用市场的之后,用户使用我们应用的时候因为各种原因程序发生了崩溃,这个是非常影响用户体验的。这种情况下,我们无法知道是否发生了崩溃,更无法知道是什么地方,因为什么原因发生了崩溃。现在市场上也有一些第三方平台替我们做了这些事情,比如腾讯的Bugly,和友盟的统计等。但是我们怎样实现自己的统计呢?

    首先我们先看下崩溃。
    Android中崩溃分为两种,一种是Java代码崩溃,一种是Native代码崩溃。本篇只分析Java代码崩溃。

    Java代码的崩溃

    Java代码的崩溃,就是Java代码发生了异常。我们先看下Java的异常类。
    这里写图片描述
    这些Java的异常类,对于编译器来说,可以分为两大类:

    unCheckedException(非检查异常):Error和RuntimeException以及他们各自的子类,都是非检查异常。换句话说,当我们编译程序的时候,编译器并不会提示我们这些异常。要么我们在编程的时候,对于可能抛出异常的代码加上try…catch,要么就等着运行的时候崩溃就好了。

    checkedException(检查异常):除了UncheckedException之外,其他的都是checkedExcption。对于这种异常,我们的代码通常都无法进行编译,因为as都会提示我们出错了。这个时候要强制加上try…catch,或者将异常throw。

    UncaughtExceptionHandler

    了解了Java的异常类之后,我们再看一个关键类。UncaughtExceptionHandler

     /**
         * Interface for handlers invoked when a <tt>Thread</tt> abruptly
         * terminates due to an uncaught exception.
         * 处理接口,当一个线程由于未捕获的异常突然停止的时候调用。
         * 
         * <p>When a thread is about to terminate due to an uncaught exception
         * the Java Virtual Machine will query the thread for its
         * <tt>UncaughtExceptionHandler</tt> using
         * {@link #getUncaughtExceptionHandler} and will invoke the handler's
         * <tt>uncaughtException</tt> method, passing the thread and the
         * exception as arguments.
         * 当一个线程由于一个未捕获的异常即将崩溃的时候,Java虚拟机将会通过【getUncaughtExceptionHandler()】方法,来
         * 查询这个线程的【UncaughtExceptionHandler】,并且会调用他的【uncaughtException()】方法,并且把当前线程
         * 和异常作为参数传进去。
         * 
         * If a thread has not had its <tt>UncaughtExceptionHandler</tt>
         * explicitly set, then its <tt>ThreadGroup</tt> object acts as its
         * <tt>UncaughtExceptionHandler</tt>. If the <tt>ThreadGroup</tt> object
         * has no
         * special requirements for dealing with the exception, it can forward
         * the invocation to the {@linkplain #getDefaultUncaughtExceptionHandler
         * default uncaught exception handler}.
         *如果一个线程没有设置他的【UncaughtExceptionHandler】,那么他的ThreadGroup对象就会作为他的
         *【UncaughtExceptionHandler】。如果【ThreadGroup】没有特殊的处理异常的需求,那么就会转调
         *【getDefaultUncaughtExceptionHandler】这个默认的处理异常的handler。
         *(线程组的东西我们先不管,我们只需要知道,如果Thread没有设置【UncaughtExceptionHandler】的话,那么
         *最终会调用【getDefaultUncaughtExceptionHandler】获取默认的【UncaughtExceptionHandler】来处理异常)
         *
         * @see #setDefaultUncaughtExceptionHandler
         * @see #setUncaughtExceptionHandler
         * @see ThreadGroup#uncaughtException
         * @since 1.5
         */
        @FunctionalInterface
        public interface UncaughtExceptionHandler {
            /**
             * Method invoked when the given thread terminates due to the
             * given uncaught exception.
             * <p>Any exception thrown by this method will be ignored by the
             * Java Virtual Machine.
             * 当传过来的【Thread】因为穿过来的未捕获的异常而停止时候调用这个方法。
             * 所有被这个方法抛出的异常,都将会被java虚拟机忽略。
             * 
             * @param t the thread
             * @param e the exception
             */
            void uncaughtException(Thread t, Throwable e);
        }

    这个类,准确的说,这个接口,其实就和我们收集崩溃日志有关系。
    如果给一个线程设置了UncaughtExceptionHandler 这个接口:
    1、这个线程中,所有未处理或者说未捕获的异常都将会由这个接口处理,也就说被这个接口给try…catch了。
    2、在这个线程中抛出异常时,java虚拟机将会忽略,也就是说,java虚拟机不会让程序崩溃了。
    3、如果没有设置,那么最终会调用getDefaultUncaughtExceptionHandler 获取默认的UncaughtExceptionHandler 来处理异常。

    我们都知道我们的android程序是跑在UI线程中的,而且我们会在程序中创建各种子线程。为了统一,如果我们给每个线程都通过setUncaughtExceptionHandler() 这个方法来设置UncaughtExceptionHandler 的话,未免太不优雅了。在上面官方代码的注释中有一句,就是如果线程没有设置UncaughtExceptionHandler ,那么会通过getDefaultUncaughtExceptionHandler 来获取默认的UncaughtExceptionHandler 来处理异常。
    这样的话,我们只需要在我们应用程序打开的时候,设置一个默认的UncaughtExceptionHandler ,就可以统一处理我们应用程序中所有的异常了!

    talk is cheap,show me the code

    首先自定义一个UncaughtExceptionHandler ,在 uncaughtException(Thread t, Throwable e) 方法中我们对抛出的异常进行处理,所谓的收集崩溃日志,就是把崩溃信息保存下来,等到合适的时机吧信息传到服务器上。不过一般选择保存信息的方法都是吧信息写入到磁盘里。代码中的逻辑也比较简单,也不做过多的解释。

    public class MyCrashHandler implements Thread.UncaughtExceptionHandler {
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            Log.e("程序出现异常了", "Thread = " + t.getName() + "\nThrowable = " + e.getMessage());
            String stackTraceInfo = getStackTraceInfo(e);
            Log.e("stackTraceInfo", stackTraceInfo);
            saveThrowableMessage(stackTraceInfo);
        }
       /**
         * 获取错误的信息
         *
         * @param throwable
         * @return
         */
        private String getStackTraceInfo(final Throwable throwable) {
            PrintWriter pw = null;
            Writer writer = new StringWriter();
            try {
                pw = new PrintWriter(writer);
                throwable.printStackTrace(pw);
            } catch (Exception e) {
                return "";
            } finally {
                if (pw != null) {
                    pw.close();
                }
            }
            return writer.toString();
        }
    
        private String logFilePath = Environment.getExternalStorageDirectory() + File.separator + "Android" +
                File.separator + "data" + File.separator + MyApp.getInstance().getPackageName() + File.separator + "crashLog";
    
        private void saveThrowableMessage(String errorMessage) {
            if (TextUtils.isEmpty(errorMessage)) {
                return;
            }
            File file = new File(logFilePath);
            if (!file.exists()) {
                boolean mkdirs = file.mkdirs();
                if (mkdirs) {
                    writeStringToFile(errorMessage, file);
                }
            } else {
                writeStringToFile(errorMessage, file);
            }
        }
    
        private void writeStringToFile(final String errorMessage, final File file) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    FileOutputStream outputStream = null;
                    try {
                        ByteArrayInputStream inputStream = new ByteArrayInputStream(errorMessage.getBytes());
                        outputStream = new FileOutputStream(new File(file, System.currentTimeMillis() + ".txt"));
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = inputStream.read(bytes)) != -1) {
                            outputStream.write(bytes, 0, len);
                        }
                        outputStream.flush();
                        Log.e("程序出异常了", "写入本地文件成功:" + file.getAbsolutePath());
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        if (outputStream != null) {
                            try {
                                outputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }).start();
        }
    
    }

    完成了我们的自定义UncaughtExceptionHandler ,接下来就是在我们程序启动的时候,把他设置为默认的就好了,一般是在application中设置。

    public class MyApp extends Application {
    
        @Override
        public void onCreate() {
            super.onCreate(); 
            MyCrashHandler handler = new MyCrashHandler();
            Thread.setDefaultUncaughtExceptionHandler(handler);
        }
    }

    小试牛刀

    开始写bug。。。

    主线程报错

    首先在我们的主线程搞一个空指针出来。

        private void testUIThreadException() {
            String string = null;
            char[] chars = string.toCharArray();
        }

    然后运行程序。可以看到打印出来了Log,而且也成功写入了手机磁盘中。
    这里写图片描述
    这里写图片描述

    子线程报错

    然后在子线程搞一个ArithmeticException,也就是除数为0时,抛出的异常。

        private void testThreadException() {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    int i = 0;
                    int s = 10 / i;
                }
            });
            thread.start();
        }

    再次运行。也是没有问题的!
    这里写图片描述
    这里写图片描述

    注意

    1、即使我们用这种方式捕获到了异常,保证程序不会闪退,如果是子线程出现了异常,那么还好,并不会影响UI线程的正常流程,但是如果是UI线程中出现了异常,那么程序就不会继续往下走,处于没有响应的状态,所以,我们处理异常的时候,应该给用户一个有好的提示,让程序优雅地退出。
    2、Thread.setDefaultUncaughtExceptionHandler(handler)方法,如果多次调用的话,会以最后一次调用时,传递的handler为准,之前设置的handler都没用。所以,这也是如果用了第三方的统计模块后,可能会出现失灵的情况。(这种情况其实也好解决,就是只设置一个handler,以这handler为主,然后在这个handler的uncaughtException 方法中,调用其他的handler的uncaughtException 方法,保证都会收到异常信息)

    如有错误,欢迎指正~

    展开全文
  • Android收集崩溃日志

    2021-10-12 10:16:07
    开发过程中或多或少肯定会出现问题,有的可以百分百复现,可以很快的...import android.content.Context; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; import android.content.
  • MNCrashMonitor 监听程序崩溃日志,直接页面展示崩溃日志列表,调试方便,测试人员可以随时给程序猿查看日志详情,可以动态添加日志内容,手机直接查看日志内容可以分享,复制,生成长截图,高亮显示。 截图 如何添加...
  • 常用获取Android崩溃日志的几种方法

    千次阅读 2021-06-06 08:12:18
    二:Android崩溃日志一、通过adb logcat获取# 清除日志,新手上路时,日志内容很多,对于能毕现的日志,可以先清除后重新获取adb logcat -c# 然后再次运行崩溃操作,再抓取日志# 存储日志到当...
  • Debug监听程序崩溃日志,直接页面展示崩溃日志列表
  • 在我们开发Android应用程序的时候,BUG的出现是难以避免的,时不时还会出现崩溃的情况,这个时候,我们急需知道造成问题的原因是什么,但是,在没有连接ADT或者AS的情况下,我们很难获取到崩溃日志,当然,如果你...
  • 安卓APP一旦发生任何报错,就会停止运行,这是令许多开发者头疼的问题,很多情况下,一些隐性BUG在测试部门通过,而在上架之后发生小面积崩溃,这时候的报错因为没有日志,导致BUG无从查起。那么,只能通过用户反馈...
  • 崩溃日志的捕获有很多种方式,最直接的就是接入三方的捕获,但是由于某些原因或者说某些原因导致不能准确的定位到崩溃的位置,也为了使应用程序测试时更好的定位崩溃位置(测试机多的时候不可能每个都去打LOG和断点) ...
  • 一、全局日志的初始化在自定义Application中添加此方法,并在自定义Application的onCreate中调用private void initCrashhandle() {CrashHandle crashHandler = CrashHandle.getInstance();// 注册...
  • Android 崩溃日志收集

    2021-06-05 09:08:27
    原理:应用出现异常后,会由默认的异常处理器来处理异常,我们要做的就是把这个任务接管过来,自己处理异常,包括收集日志,保存到本地,然后上传到服务器。步骤1.自定义类 实现Thread.UncaughtExceptionHandler ...
  • 当我使用Android Studio时,应用程序崩溃时清空Logcat看不到崩溃日志。通过设置logcatfilter : 1、单击logcat右侧的编辑filterconfiguration 2、设置您的应用程序ID,然后单击确定 此时就可以看到崩溃日志了! ...
  • android日志分析&崩溃拦截,包括如下: andorid手机程序错误信息的demo.rar android app异常收集处理.rar android java 通用代码,关于用properties存储打印的Log.zip android 错误收集工具.rar android 错误...
  • //获取崩溃信息 final Thread.UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler(); Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
  • Android程序崩溃处理

    千次阅读 2021-12-28 09:55:10
    程序崩溃日志输出
  • 今天来写点Android崩溃的东西,在我们写...所以,今天我们来说说Android崩溃日志的抓取。在程序界面有一句话很流行,那就是不要重复造轮子。现在市面上有很多的崩溃日志抓取工具,比如腾讯的bugly,不管是eclipse还...
  • Android 应用程序崩溃,是最让人头疼的,崩溃日志的获取有各种方法,下面给出最简单的一种 找到SDK目录D:\MySDK\tools\lib\monitor-x86_64/monitor.exe,双击它! 就能看到应用程序所有日志,还能保存txt文本 ...
  • Android中采集崩溃日志

    2021-06-10 07:50:13
    } // 退出程序 android.os.Process.killProcess(android.os.Process.myPid()); System.exit(1); } } /** * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成. * * @param ex * @return true:如果处理了该...
  • android程序崩溃If there’s anything common among all the developers out there, be it front-end, back-end, or even game developers, it is that we hate production bugs. Especially when these bugs result...
  • Android抓取崩溃日志

    万次阅读 2016-01-13 10:04:16
    崩溃日志抓取 感谢 “liuhe688” 大神的无私分享 这里是博客地址:http://blog.csdn.net/liuhe688/article/details/6584143#在Android里如果运行时出现异常,而开发者又没有手动去catch的话,程序就会崩溃; 在...
  • Android捕获全局异常源码.rar,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • Android捕捉崩溃日志并输出日志文件

    千次阅读 2019-08-23 09:29:21
    Android捕捉崩溃日志并输出日志文件 当程序与运行时发生崩溃,可以捕捉到当前崩溃的日志信息并写入文件保存到指定的目录下。这里还做了最大文件数量限制,超过数量即删除旧日志文件。 import java.io.BufferedReader...
  • 今天来写点Android崩溃的东西,在我们写...所以,今天我们来说说Android崩溃日志的抓取。在程序界面有一句话很流行,那就是不要重复造轮子。现在市面上有很多的崩溃日志抓取工具,比如腾讯的bugly,不管是eclipse还...
  • android闪退获取日志方法: 1.下载adb工具包 网上很多 下载解压就可以了。 2.注意事项 请确保电脑上只连接了一台手机设备(最好只连接一条USB线),同时确保手机已开启USB调试模式(在开发者选项里面开启) 3.使用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,395
精华内容 6,158
关键字:

安卓程序崩溃日志