5章 性能平台GodEye源码分析-第三方模块

最新推荐文章于 2024-08-24 08:55:24 发布
最新推荐文章于 2024-08-24 08:55:24 发布
阅读量522 收藏 1
点赞数 1
文章标签： android GodEye 性能 性能监控 APM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30379689/article/details/112184202
版权

5. 第三方模块

5.1 Crash（XCrash）

在这里插入图片描述

Crash监控崩溃后的堆栈上传，作者采用接入爱奇艺的XCrash框架

源码分析

1、启动Crash的监控

Crash的监控通过反射启动XCrash框架，因为XCrash的框架引入，可能会和你的项目有些框架的冲突，作者将XCrash的初始化代码放置在另一个Module中，这样方便热插拔当前的崩溃框架

public class Crash extends ProduceableSubject<List<CrashInfo>> implements Install<CrashConfig> {
    private boolean mInstalled;
    private CrashConfig mConfig;

    @Override
    public synchronized boolean install(final CrashConfig crashContext) {
        if (mInstalled) {
            L.d("Crash already installed, ignore.");
            return true;
        }
        Consumer<List<CrashInfo>> consumer = this::produce;
        // auto detect crash collector provider
        try {
            ReflectUtil.invokeStaticMethodUnSafe("cn.hikyson.android.godeye.xcrash.GodEyePluginXCrash", "init",
                    new Class<?>[]{CrashConfig.class, Consumer.class}, new Object[]{crashContext, consumer});
        } catch (Exception e) {
            L.d("Crash can not be installed:", e.getLocalizedMessage());
            return false;
        }
        mConfig = crashContext;
        mInstalled = true;
        L.d("Crash installed.");
        return true;
    }
}

2、采集Crash信息

Crash初始化主要参考XCrash文档

public class GodEyePluginXCrash {

    /**
     * entrace
     *
     * @param crashContext
     * @param consumer
     */
    public static void init(CrashConfig crashContext, Consumer<List<CrashInfo>> consumer) {
        ICrashCallback callback = (logPath, emergency) -> {
            try {
                sendThenDeleteCrashLog(logPath, emergency, crashContext, consumer);
            } catch (IOException e) {
                L.e(e);
            }
        };
        XCrash.init(GodEye.instance().getApplication(), new XCrash.InitParameters()
                .setAppVersion(getAppVersion(GodEye.instance().getApplication()))
                .setJavaRethrow(true)
                .setJavaLogCountMax(10)
                .setJavaDumpAllThreadsWhiteList(new String[]{"^main$", "^Binder:.*", ".*Finalizer.*"})
                .setJavaDumpAllThreadsCountMax(10)
                .setJavaCallback(callback)
                .setNativeRethrow(true)
                .setNativeLogCountMax(10)
                .setNativeDumpAllThreadsWhiteList(new String[]{"^xcrash\\.sample$", "^Signal Catcher$", "^Jit thread pool$", ".*(R|r)ender.*", ".*Chrome.*"})
                .setNativeDumpAllThreadsCountMax(10)
                .setNativeCallback(callback)
                .setAnrRethrow(true)
                .setAnrLogCountMax(10)
                .setAnrCallback(callback)
                .setPlaceholderCountMax(3)
                .setPlaceholderSizeKb(512)
                .setLogFileMaintainDelayMs(1000));
        Schedulers.computation().scheduleDirect(() -> {
            try {
                sendThenDeleteCrashLogs(consumer);
            } catch (Exception e) {
                L.e(e);
            }
        });
    }
}

Crash的初始化之后，会通过sendThenDeleteCrashLogs获取当前已有的崩溃堆栈信息，参数consumer就是通过反射传递过来的日志器，如果当前存在Crash的信息，则获取XCrash的崩溃信息，将Crash信息封装后发送出去

private static void sendThenDeleteCrashLogs(Consumer<List<CrashInfo>> consumer) throws Exception {
    File[] files = TombstoneManager.getAllTombstones();
    List<CrashInfo> crashes = new ArrayList<>();
    for (File f : files) {
        try {
            crashes.add(wrapCrashMessage(TombstoneParser.parse(f.getAbsolutePath(), null)));
        } catch (IOException e) {
            L.e(e);
        }
    }
    if (!crashes.isEmpty()) {
        L.d("Crash produce message when install, crash count:%s", crashes.size());
        consumer.accept(crashes);
        TombstoneManager.clearAllTombstones();
    }
}

3、总结

借助当前的第三方的优秀框架，通过热插拔的形式，引入到我们的性能监控中

5.2 LeakCanary

在这里插入图片描述

LeakCanary监控应用的内存泄漏信息，作者采用接入LeakCanary框架

源码分析

1、启动LeakCanary的监控

LeakCanary的监控通过反射启动LeakCanary框架

public class Leak extends ProduceableSubject<LeakInfo> implements Install<LeakConfig> {
    private boolean mInstalled;
    private LeakConfig mConfig;

    @Override
    public synchronized boolean install(LeakConfig config) {
        if (mInstalled) {
            L.d("Leak already installed, ignore.");
            return true;
        }
        mConfig = config;
        try {
            ReflectUtil.invokeStaticMethodUnSafe("cn.hikyson.android.godeye.leakcanary.GodEyePluginLeakCanary", "install",
                    new Class<?>[]{Application.class, Leak.class}, new Object[]{GodEye.instance().getApplication(), this});
        } catch (Exception e) {
            L.d("Leak can not be installed, please add android-godeye-leakcanary dependency first:", e);
            return false;
        }
        mInstalled = true;
        L.d("Leak installed.");
        return true;
    }
}

2、采集LeakCanary信息

LeakCanary初始化主要参考LeakCanary文档，当发生内存泄漏的时候，将当前的内存信息封装后发送出去

public class GodEyePluginLeakCanary {
    @Keep
    public static void install(final Application application, final Leak leakModule) {
        ThreadUtil.sMain.execute(new Runnable() {
            @Override
            public void run() {
                AppWatcher.INSTANCE.manualInstall(application);
                LeakCanary.INSTANCE.showLeakDisplayActivityLauncherIcon(false);
                LeakCanary.setConfig(new LeakCanary.Config().newBuilder()
                        .requestWriteExternalStoragePermission(false)
                        .dumpHeap(true)
                        .onHeapAnalyzedListener(new OnHeapAnalyzedListener() {
                            @Override
                            public void onHeapAnalyzed(@NotNull HeapAnalysis heapAnalysis) {
                                if (heapAnalysis instanceof HeapAnalysisFailure) {
                                    L.w("GodEyePluginLeakCanary leak analysis failure:" + heapAnalysis.toString());
                                    return;
                                }
                                if (!(heapAnalysis instanceof HeapAnalysisSuccess)) {
                                    L.w("GodEyePluginLeakCanary leak analysis type error: " + heapAnalysis.getClass().getName());
                                    return;
                                }
                                final HeapAnalysisSuccess analysisSuccess = (HeapAnalysisSuccess) heapAnalysis;
                                IteratorUtil.forEach(analysisSuccess.getAllLeaks().iterator(), new Consumer<shark.Leak>() {
                                    @Override
                                    public void accept(shark.Leak leak) {
                                        leakModule.produce(new LeakInfo(analysisSuccess.getCreatedAtTimeMillis(), analysisSuccess.getAnalysisDurationMillis(), leak));
                                    }
                                });
                            }
                        }).build());
                AppWatcher.setConfig(new AppWatcher.Config().newBuilder().enabled(true).build());
            }
        });
    }
}

3、总结

原理同样很简单，借助当前的第三方的优秀框架，通过热插拔的形式，引入到我们的性能监控中

5.3 NetWork（OkHttp）

在这里插入图片描述

在这里插入图片描述

NetWork的监控主要是计算网络的请求时间，通过OkHttp提供的拦截器中，有对应的回调

源码分析

1、启动NetWork的监控

NetWork的监控通过OkHttp自定义拦截器和回调去实现，项目的网络请求，就由当前初始化的这个OkHttp客户端去请求，即可达到监听的效果

  • eventListenerFactory：表示OkHttp监听请求到结束所有过程的监听器
  • addNetworkInterceptor：表示设置有网络时候的拦截器
GodEyePluginOkNetwork godEyePluginOkNetwork = new GodEyePluginOkNetwork();
mZygote = new OkHttpClient.Builder().eventListenerFactory(godEyePluginOkNetwork).addNetworkInterceptor(godEyePluginOkNetwork).build();

2、采集NetWork信息

采集网络信息都在拦截器和监听器里面

public class GodEyePluginOkNetwork extends OkHttpNetworkContentInterceptor implements EventListener.Factory {

    public GodEyePluginOkNetwork() {
        super(new HttpContentTimeMapping());
    }

    @Override
    public EventListener create(Call call) {
        return new OkNetworkEventListener(this.mHttpContentTimeMapping);
    }
}

由于OkHttp封装得很好，所有的信息回调都会有，这里只是做时间的记录和一些关键的信息的记录

  • RequestHeader时间
  • RequestBody时间
  • ResponseHeader时间
  • ResponseBody时间
  • Connect时间
  • Dns时间
  • Other时间
class OkNetworkEventListener extends EventListener {
    private NetworkInfo<HttpContent> mNetworkInfo;
    private long mCallStartTimeMillis;
    private long mDnsStartTimeMillis;
    private long mConnectionStartTimeMillis;
    private long mRequestHeadersStartTimeMillis;
    private long mRequestBodyStartTimeMillis;
    private long mResponseHeadersStartTimeMillis;
    private long mResponseBodyStartTimeMillis;
    private HttpContentTimeMapping mHttpContentTimeMapping;

    OkNetworkEventListener(HttpContentTimeMapping httpContentTimeMapping) {
        this.mHttpContentTimeMapping = httpContentTimeMapping;
        this.mNetworkInfo = new NetworkInfo<>();
        this.mNetworkInfo.networkTime = new NetworkTime();
        this.mNetworkInfo.extraInfo = new HashMap<>();
    }

    @Override
    public void callStart(Call call) {
        super.callStart(call);
        mCallStartTimeMillis = System.currentTimeMillis();
        this.mNetworkInfo.summary = call.request().method() + " " + call.request().url();
    }

    @Override
    public void dnsStart(Call call, String domainName) {
        super.dnsStart(call, domainName);
        mDnsStartTimeMillis = System.currentTimeMillis();
    }

    @Override
    public void dnsEnd(Call call, String domainName, List<InetAddress> inetAddressList) {
        super.dnsEnd(call, domainName, inetAddressList);
        this.mNetworkInfo.networkTime.networkTimeMillisMap.put("DnsTime", System.currentTimeMillis() - mDnsStartTimeMillis);
    }

    @Override
    public void connectStart(Call call, InetSocketAddress inetSocketAddress, Proxy proxy) {
        super.connectStart(call, inetSocketAddress, proxy);
        mConnectionStartTimeMillis = System.currentTimeMillis();
    }

    @Override
    public void connectEnd(Call call, InetSocketAddress inetSocketAddress, Proxy proxy, Protocol protocol) {
        super.connectEnd(call, inetSocketAddress, proxy, protocol);
        this.mNetworkInfo.networkTime.networkTimeMillisMap.put("ConnectTime", System.currentTimeMillis() - mConnectionStartTimeMillis);
    }

    @Override
    public void connectFailed(Call call, InetSocketAddress inetSocketAddress, Proxy proxy, Protocol protocol,
                              IOException ioe) {
        super.connectFailed(call, inetSocketAddress, proxy, protocol, ioe);
        this.mNetworkInfo.networkTime.networkTimeMillisMap.put("ConnectTime", System.currentTimeMillis() - mConnectionStartTimeMillis);
    }

    @Override
    public void connectionAcquired(Call call, Connection connection) {
        super.connectionAcquired(call, connection);
        Handshake handshake = connection.handshake();
        String cipherSuite = "";
        String tlsVersion = "";
        if (handshake != null) {
            cipherSuite = handshake.cipherSuite().javaName();
            tlsVersion = handshake.tlsVersion().javaName();
        }
        Socket socket = connection.socket();
        int localPort = socket.getLocalPort();
        int remotePort = socket.getPort();
        String localIp = "";
        String remoteIp = "";
        InetAddress localAddress = socket.getLocalAddress();
        if (localAddress != null) {
            localIp = localAddress.getHostAddress();
        }
        InetAddress remoteAddress = socket.getInetAddress();
        if (remoteAddress != null) {
            remoteIp = remoteAddress.getHostAddress();
        }
        mNetworkInfo.extraInfo.put("cipherSuite", cipherSuite);
        mNetworkInfo.extraInfo.put("tlsVersion", tlsVersion);
        mNetworkInfo.extraInfo.put("localIp", localIp);
        mNetworkInfo.extraInfo.put("localPort", localPort);
        mNetworkInfo.extraInfo.put("remoteIp", remoteIp);
        mNetworkInfo.extraInfo.put("remotePort", remotePort);
    }

    @Override
    public void requestHeadersStart(Call call) {
        super.requestHeadersStart(call);
        mRequestHeadersStartTimeMillis = System.currentTimeMillis();
    }

    @Override
    public void requestHeadersEnd(Call call, Request request) {
        super.requestHeadersEnd(call, request);
        this.mNetworkInfo.networkTime.networkTimeMillisMap.put("RequestHeadersTime", System.currentTimeMillis() - mRequestHeadersStartTimeMillis);
    }

    @Override
    public void requestBodyStart(Call call) {
        super.requestBodyStart(call);
        mRequestBodyStartTimeMillis = System.currentTimeMillis();
    }

    @Override
    public void requestBodyEnd(Call call, long byteCount) {
        super.requestBodyEnd(call, byteCount);
        this.mNetworkInfo.networkTime.networkTimeMillisMap.put("RequestBodyTime", System.currentTimeMillis() - mRequestBodyStartTimeMillis);
    }

    @Override
    public void responseHeadersStart(Call call) {
        super.responseHeadersStart(call);
        mResponseHeadersStartTimeMillis = System.currentTimeMillis();
    }

    @Override
    public void responseHeadersEnd(Call call, Response response) {
        super.responseHeadersEnd(call, response);
        this.mNetworkInfo.networkTime.networkTimeMillisMap.put("ResponseHeadersTime", System.currentTimeMillis() - mResponseHeadersStartTimeMillis);
    }

    @Override
    public void responseBodyStart(Call call) {
        super.responseBodyStart(call);
        mResponseBodyStartTimeMillis = System.currentTimeMillis();
    }

    @Override
    public void responseBodyEnd(Call call, long byteCount) {
        super.responseBodyEnd(call, byteCount);
        this.mNetworkInfo.networkTime.networkTimeMillisMap.put("ResponseBodyTime", System.currentTimeMillis() - mResponseBodyStartTimeMillis);
    }

    @Override
    public void callEnd(Call call) {
        super.callEnd(call);
        this.mNetworkInfo.networkTime.totalTimeMillis = System.currentTimeMillis() - mCallStartTimeMillis;
        mNetworkInfo.networkContent = mHttpContentTimeMapping.removeAndGetRecord(call);
        if (mNetworkInfo.networkContent != null) {
            if (mNetworkInfo.networkContent.httpResponse != null) {
                mNetworkInfo.isSuccessful = isSuccessful(mNetworkInfo.networkContent.httpResponse.code);
            }
            if (mNetworkInfo.networkContent.httpResponse != null) {
                mNetworkInfo.message = mNetworkInfo.networkContent.httpResponse.message;
            }
        }
        try {
            GodEyeHelper.onNetworkEnd(mNetworkInfo);
        } catch (UninstallException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void callFailed(Call call, IOException ioe) {
        super.callFailed(call, ioe);
        this.mNetworkInfo.networkTime.totalTimeMillis = System.currentTimeMillis() - mCallStartTimeMillis;
        mNetworkInfo.isSuccessful = false;
        mNetworkInfo.message = String.valueOf(ioe);
        mNetworkInfo.networkContent = mHttpContentTimeMapping.removeAndGetRecord(call);
        try {
            GodEyeHelper.onNetworkEnd(mNetworkInfo);
        } catch (UninstallException e) {
            e.printStackTrace();
        }
    }

    private static boolean isSuccessful(int code) {
        return code >= 200 && code < 300;
    }
}

最后通过GodEyeHelper.onNetworkEnd(mNetworkInfo);将数据发送出去

public static void onNetworkEnd(NetworkInfo networkInfo) throws UninstallException {
    GodEye.instance().<Network>getModule(GodEye.ModuleName.NETWORK).produce(networkInfo);
    L.d("GodEyeHelper onNetworkEnd: %s", networkInfo == null ? "null" : networkInfo.toSummaryString());
}

3、总结

原理同样很简单，借助当前的第三方的优秀框架提供的回调参数，通过热插拔的形式，引入到我们的性能监控中

5.4 MethodCanary

在这里插入图片描述

MethodCanary用的是作者的另一个框架，通过调用开始和结束，采集当前时间段内线程中执行的函数和时间线

源码分析

1、启动MethodCanary的监控

MethodCanary的启动没做任何事情，因为其采集是需要手动调用才可以

public class MethodCanary extends ProduceableSubject<MethodsRecordInfo> implements Install<MethodCanaryConfig> {
    private boolean mInstalled = false;
    private MethodCanaryConfig mMethodCanaryContext;

    @Override
    public synchronized boolean install(final MethodCanaryConfig methodCanaryContext) {
        if (this.mInstalled) {
            L.d("MethodCanary already installed, ignore.");
            return true;
        }
        this.mMethodCanaryContext = methodCanaryContext;
        this.mInstalled = true;
        L.d("MethodCanary installed.");
        return true;
    }
}

2、采集MethodCanary信息

采集的过程使用MethodCanary提供的Api，需要手动调用启动和结束，结束后将返回的方法信息发送出去

public synchronized void startMonitor(String tag) {
    try {
        if (!isInstalled()) {
            L.d("MethodCanary start monitor fail, not installed.");
            return;
        }
        cn.hikyson.methodcanary.lib.MethodCanary.get().startMethodTracing(tag);
        L.d("MethodCanary start monitor success.");
    } catch (Exception e) {
        L.d("MethodCanary start monitor fail:" + e);
    }
}

public synchronized void stopMonitor(String tag) {
    try {
        if (!isInstalled()) {
            L.d("MethodCanary stop monitor fail, not installed.");
            return;
        }
        cn.hikyson.methodcanary.lib.MethodCanary.get().stopMethodTracing(tag
                , new cn.hikyson.methodcanary.lib.MethodCanaryConfig(this.mMethodCanaryContext.lowCostMethodThresholdMillis()), (sessionTag, startMillis, stopMillis, methodEventMap) -> {
                    long start0 = System.currentTimeMillis();
                    MethodsRecordInfo methodsRecordInfo = MethodCanaryConverter.convertToMethodsRecordInfo(startMillis, stopMillis, methodEventMap);
//                        recordToFile(methodEventMap, methodsRecordInfo);
                    long start1 = System.currentTimeMillis();
                    MethodCanaryConverter.filter(methodsRecordInfo, this.mMethodCanaryContext);
                    long end = System.currentTimeMillis();
                    L.d(String.format("MethodCanary output success! cost %s ms, filter cost %s ms", end - start0, end - start1));
                    produce(methodsRecordInfo);
                });
        L.d("MethodCanary stopped monitor and output processing...");
    } catch (Exception e) {
        L.d("MethodCanary stop monitor fail:" + e);
    }
}

作者也是通过Web点击开始和结束操作当前的MethodCanary

public class WebSocketMethodCanaryProcessor implements WebSocketProcessor {
    @Override
    public void process(WebSocket webSocket, JSONObject msgJSONObject) {
        try {
            if ("start".equals(msgJSONObject.optString("payload"))) {
                GodEyeHelper.startMethodCanaryRecording("AndroidGodEye-Monitor-Tag");
            } else if ("stop".equals(msgJSONObject.optString("payload"))) {
                GodEyeHelper.stopMethodCanaryRecording("AndroidGodEye-Monitor-Tag");
            }
            webSocket.send(new ServerMessage("methodCanaryMonitorState", Collections.singletonMap("isRunning", GodEyeHelper.isMethodCanaryRecording("AndroidGodEye-Monitor-Tag"))).toString());
        } catch (UninstallException e) {
            L.e(String.valueOf(e));
        }
    }
}

3、总结

MethodCanary主要是依赖于作者的第三方库，通过框架的回调，获取我们想要的函数信息

许英俊潇洒
关注
Godeyes_Android_V2.1_(for_AndroidStudio).zip
12-25
android studio插件godeyes，性能测试-crash检测，自动生成报告
1章 性能平台GodEye源码分析-整体架构
点击置顶文章查看博客目录（全站式导航）
12-29 732
1. 基础概念 1.1 GodEye简述 用原话说：AndroidGodEye是一个可以在PC浏览器中实时监控Android性能数据指标的工具，你可以通过wifi/usb连接手机和pc，通过pc浏览器实时监控手机性能 1.2 GodEye项目预览 系统分为三部分： Core：核心部分，提供所有模块 Debug Monitor：提供Debug阶段开发者面板 Toolbox：快速接入工具集，给开发者提供各种便捷接入的工具 其支持的功能分为： 模块名称 描述 CPU 手机和App Cpu检测
GodEye 开源项目安装与使用指南
最新发布
gitblog_00239的博客
08-24 500
GodEye 开源项目安装与使用指南 GodEyeAutomaticly display Log,Crash,Network,ANR,Leak,CPU,RAM,FPS,NetFlow,Folder and etc with one line of code based on Swift. Just like God opened his eyes项目地址:https://gitcode.com/...
AndroidGodEye
未来很长，但我会努力的走下去。
11-26 1319
Android开发者在性能检测方面的工具一直比较匮乏，仅有的一些工具，比如Android Device Monitor，使用起来也有些繁琐，使用起来对开发者有一定的要求。而线上的App监控更无从谈起。所以需要有一个系统能够提供Debug和Release阶段全方位的监控，更深入地了解对App运行时的状态。 概览 http://p.codekk.com/detail/javascript/Ky...
（4.2.46）AndroidGodEye源码整体结构分析
JAVA成长之路
03-13 1314
一、概览 1.1 快速开始 STEP1: 引入依赖，使用gradle STEP2: 模块安装，GodEye类是AndroidGodEye的核心类，所有模块由它提供。 可选部分 STEP3： Debug面板安装，GodEyeMonitor类是AndroidGodEye的Debug监控面板的主要类，用来开始或者停止Debug面板的监控。 STEP4：完成！开始使用： 二、cn.hiky...
将异常一网打尽，爱奇艺开源xCrash是如何做的？
Java和Android架构
09-23 1652
链接：https://juejin.cn/post/6991356414069309477需要注意一点，因为开源项目一直在更新，文章和最新项目可能有些许变化，但基本不影响学习~1Xcras...
百度地图毕业设计源码-godeye:神眼
06-06
百度地图毕业设计源码 简介 godeye 监控开始 对于一个基本的分布式系统调用跟踪系统，大致需要满足基本的特性：低侵入性，高性能，高可用容错，低丢失率等，下文绍这几个特性的简单实现。 特点 低侵入性 对于业务...
曙光GodEye-NIDS：网络入侵检测系统，守护3000种攻击
6. 技术优势：GodEye-NIDS采用全面的特征检测、协议分析和内容分析技术，确保了对网络流量的深度理解和精确识别，提升了入侵检测系统的性能和有效性。 曙光GodEye-NIDS网络入侵检测系统凭借其强大的防护功能、智能...
AndroidGodEye：一个应用程序性能监视器（APM），例如“ Android Studio profiler”，您可以轻松地在浏览器中实时监视应用程序的性能
02-21
Core提供所有性能模块并生成性能数据。 调试监视器提供了一个仪表板来显示这些性能数据。 工具箱使开发人员易于使用此库。 特征 模块名称 描述 中央处理器 设备和应用的CPU信息 电池 电池信息 第一人称射击 FPS...
百度地图毕业设计源码：godeye分布式调用跟踪系统
给定的文件中提到了“godeye-master”，这可能表明源码被打包在一个压缩文件中，通常这种压缩包文件会包含项目的所有源代码文件、文档、构建脚本以及可能的测试用例等。这允许用户下载后，可以直接在本地环境中编译...
MethodCanary：MethodCanary是记录方法调用的工具
02-04
方法金丝雀 MethodCanary是衡量方法成本的工具。 为编写。 快速开始 Step0下载 根build.gradle buildscript { repositories { jcenter() } dependencies { classpath ' cn.hikyson.methodcanary:plugin:VERSION ' } } 模块com.android.application apply plugin : ' cn.hikyson.methodcanary.plugin ' implementatio
xCrash使用篇
cxmfzu的博客
10-20 9631
的地方
Android 应用崩溃捕获工具 xCrash
纸上得来终觉浅，绝知此事要躬行
09-23 3488
源代码：https://gitee.com/mirrors/xCrash xCrash xCrash 能为安卓 app 提供捕获 java 崩溃，native 崩溃和 ANR 的能力。不需要 root 权限或任何系统权限。 xCrash 能在 app 进程崩溃或 ANR 时，在你指定的目录中生成一个 tombstone 文件（格式与安卓系统的 tombstone 文件类似）。 xCr...
AndroidGodEye 使用教程
gitblog_00432的博客
08-07 449
AndroidGodEye 使用教程 AndroidGodEyeInternal inspect tool for QA peoples.项目地址:https://gitcode.com/gh_mirrors/an/AndroidGodEye 项目介绍 AndroidGodEye 是一个性能监控工具，适用于 Android 应用，不仅限于性能数据。它可以在 PC 浏览器中实时监控应用的性能指标，...
xCrash捕获Native异常(一)
cxmfzu的博客
12-30 2086
Native异常 android 开发过程中有时候需要使用JNI的方式调用C/C++的库。因此在调试的过程如果发现崩溃异常，如果能够获取C/C++ 的异常堆栈，则可以方便的确定哪一行代码出现了问题，方便快速的定位问题。 在捕获Native异常中，原理上面基本是采用linux的信号机制。 linux信号机制 关于Unix-like系统的信号机制可以参见《深入Linux内核》第4章 中断和异常 ；第1...
Android之xCrash介绍
u012739527的博客
09-12 543
image.png xCrash xCrash是爱奇艺开源的在android平台上面捕获异常的开源库。 xCrash能为安卓 APP提供捕获Java崩溃异常，native崩溃异常和ANR异常。 xCrash 能在 App 进程崩溃或 ANR 时，在你指定的目录中生成一个 tombstone 文件(格式与安卓系统的 tombstone 文件类似)。 xCrash项目地址： github：h...
Android调试之tombstone信息的分析
Tony的专栏
08-12 8827
tombstone一般是由Dalvik错误、状态监视调试器、C层代码以及libc的一些问题导致的。 当系统发生tombstone的时候，kernel首先会上报一个严重的警告信号（signal）,上层接收到之后， 进程的调试工具会把进程中当时的调用栈现场保存起来，并在系统创建了data/tombstones目录后把 异常时的进程信息写在此目录里面，开发者需要通过调用栈来分析整个调用流程来找出出
Android12系统源码分析：NativeTombstoneManager
m0_62167422的博客
01-08 1823
概述 Android12 新增的 system_server 进程（LocalService）本地服务，用于管理native tombstones。 该服务在开机 SystemServer 初始化流程启动，添加到 LocalService，然后启动一个 ServiceThread 线程用于（mHandler.post）处理本服务的业务。 NativeTombstoneManager 的功能主要是： 监听/data/tombstones目录文件变动，解析为 TombstoneFile 对象保存，通知 dro
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

许英俊潇洒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值