[源码]BlockCanary学习笔记

BlockCanary检查APP卡顿，相关使用方法以及源码学习

一、使用方法
1.添加依赖

dependencies {
    // most often used way, enable notification to notify block event
    compile 'com.github.markzhai:blockcanary-android:1.5.0'

    // this way you only enable BlockCanary in debug package
    // debugCompile 'com.github.markzhai:blockcanary-android:1.5.0'
    // releaseCompile 'com.github.markzhai:blockcanary-no-op:1.5.0'
}

2.在Application初始化并且启动

public class DemoApplication extends Application {
    @Override
    public void onCreate() {
        // ...
        // Do it on main process
        BlockCanary.install(this, new AppBlockCanaryContext()).start();
    }
}

二、原理
1.原理概述：给主线程Looper设置一个Printer，记录dispatchMessage方法执行的耗时时间。如果耗时超过给定的阙值，则认为主线程卡顿了。如果发生卡顿，收集所有信息(CPU、设备、堆栈)并且格式化，debug时通知烂提示，release时上传服务器。

2.Looper源码片断

for (;;) {
    Message msg = queue.next(); // might block
    if (msg == null) {
        // No message indicates that the message queue is quitting.
        return;
    }

    // This must be in a local variable, in case a UI event sets the logger
    final Printer logging = me.mLogging;
    if (logging != null) {
        logging.println(">>>>> Dispatching to " + msg.target + " " +
            msg.callback + ": " + msg.what);
    }
    final long traceTag = me.mTraceTag;
    if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
        Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
    }
    try {
        msg.target.dispatchMessage(msg);
    } finally {
        if (traceTag != 0) {
            Trace.traceEnd(traceTag);
        }
    }

    if (logging != null) {
        logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
    }

    // Make sure that during the course of dispatching the
    // identity of the thread wasn't corrupted.
    final long newIdent = Binder.clearCallingIdentity();
    if (ident != newIdent) {
        Log.wtf(TAG, "Thread identity changed from 0x"
            + Long.toHexString(ident) + " to 0x"
            + Long.toHexString(newIdent) + " while dispatching to "
            + msg.target.getClass().getName() + " "
            + msg.callback + " what=" + msg.what);
    }

    msg.recycleUnchecked();
}

3.BlockCanary原理图

三、源码分析
1.Application初始化以及启动

BlockCanary.install(this, new AppBlockCanaryContext()).start();

2.start过程

/**
 * Start monitoring.
 */
public void start() {
    //防止多次启动
    if (!mMonitorStarted) {
        mMonitorStarted = true;
        //给主线程设置Printer
        Looper.getMainLooper().setMessageLogging(mBlockCanaryCore.monitor);
    }
}

3.intsall过程

/**
 * Install {@link BlockCanary}
 *
 * @param context            Application context
 * @param blockCanaryContext BlockCanary context
 * @return {@link BlockCanary}
 */
public static BlockCanary install(Context context, BlockCanaryContext blockCanaryContext) {
    //初始化用户配置也即是用户传入的AppBlockCanaryContext
    BlockCanaryContext.init(context, blockCanaryContext);
    //显示/隐藏桌面Block图标，也就是是否禁用组建①
    setEnabled(context, DisplayActivity.class, BlockCanaryContext.get().displayNotification());
    //返回单例对象②
    return get();
}

①是否启动Activity组件

private static void setEnabled(Context context,
                                   final Class<?> componentClass,
                                   final boolean enabled) {
    final Context appContext = context.getApplicationContext();
    //单独提交到一个IO线程去执行，作者参考LeakCanary
    executeOnFileIoThread(new Runnable() {
        @Override
        public void run() {
            setEnabledBlocking(appContext, componentClass, enabled);
        }
    });
}

// these lines are originally copied from LeakCanary: Copyright (C) 2015 Square, Inc.
private static final Executor fileIoExecutor = newSingleThreadExecutor("File-IO");

private static void setEnabledBlocking(Context appContext,
                                       Class<?> componentClass,
                                       boolean enabled) {
    ComponentName component = new ComponentName(appContext, componentClass);
    PackageManager packageManager = appContext.getPackageManager();
    //根据用户配置禁止或者启动组件
    int newState = enabled ? COMPONENT_ENABLED_STATE_ENABLED : COMPONENT_ENABLED_STATE_DISABLED;
    // Blocks on IPC.
    packageManager.setComponentEnabledSetting(component, newState, DONT_KILL_APP);
}
// end of lines copied from LeakCanary

②install返回外观类BlockCanary单例对象

/**
 * Get {@link BlockCanary} singleton.
 * 单例模式DCL
 * @return {@link BlockCanary} instance
 */
public static BlockCanary get() {
    if (sInstance == null) {
        synchronized (BlockCanary.class) {
            if (sInstance == null) {
                sInstance = new BlockCanary();
            }
        }
    }
    return sInstance;
}

3.外观类BlockCanary类初始化时，会初始化核心内部类以及添加拦截器

public final class BlockCanary {

    private static final String TAG = "BlockCanary";
    //单例对象
    private static BlockCanary sInstance;
    //核心内部类对象
    private BlockCanaryInternals mBlockCanaryCore;
    //是否已经开启卡顿监测，防止多次开启
    private boolean mMonitorStarted = false;

    private BlockCanary() {
        //将配置赋值给内部核心类
        BlockCanaryInternals.setContext(BlockCanaryContext.get());
        //单例模式获取核心内部类②
        mBlockCanaryCore = BlockCanaryInternals.getInstance();
        //添加拦截器，用户实现的BlockInterceptor接口
        mBlockCanaryCore.addBlockInterceptor(BlockCanaryContext.get());
        //如果用户禁用通知则不添加通知拦截器①
        if (!BlockCanaryContext.get().displayNotification()) {
            return;
        }
        mBlockCanaryCore.addBlockInterceptor(new DisplayService());

    }
......
}

①分析内部核心类之前先看下DisplayService类，这是一个拦截器，在发生卡顿时通知栏发送通知，代码作了版本适配

final class DisplayService implements BlockInterceptor {

    private static final String TAG = "DisplayService";

    @Override
    public void onBlock(Context context, BlockInfo blockInfo) {
        //发生卡顿时就显示通知，点击通知栏进入DisplayActivity界面
        Intent intent = new Intent(context, DisplayActivity.class);
        intent.putExtra("show_latest", blockInfo.timeStart);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(context, 1, intent, FLAG_UPDATE_CURRENT);
        String contentTitle = context.getString(R.string.block_canary_class_has_blocked, blockInfo.timeStart);
        String contentText = context.getString(R.string.block_canary_notification_message);
        show(context, contentTitle, contentText, pendingIntent);
    }
    //根据版本进行适配通知栏
    @TargetApi(HONEYCOMB)
    private void show(Context context, String contentTitle, String contentText, PendingIntent pendingIntent) {
        NotificationManager notificationManager = (NotificationManager)
                context.getSystemService(Context.NOTIFICATION_SERVICE);

        Notification notification;
        if (SDK_INT < HONEYCOMB) {
            notification = new Notification();
            notification.icon = R.drawable.block_canary_notification;
            notification.when = System.currentTimeMillis();
            notification.flags |= Notification.FLAG_AUTO_CANCEL;
            notification.defaults = Notification.DEFAULT_SOUND;
            try {
                Method deprecatedMethod = notification.getClass().getMethod("setLatestEventInfo", Context.class, CharSequence.class, CharSequence.class, PendingIntent.class);
                deprecatedMethod.invoke(notification, context, contentTitle, contentText, pendingIntent);
            } catch (NoSuchMethodException | IllegalAccessException | IllegalArgumentException
                    | InvocationTargetException e) {
                Log.w(TAG, "Method not found", e);
            }
        } else {
            Notification.Builder builder = new Notification.Builder(context)
                    .setSmallIcon(R.drawable.block_canary_notification)
                    .setWhen(System.currentTimeMillis())
                    .setContentTitle(contentTitle)
                    .setContentText(contentText)
                    .setAutoCancel(true)
                    .setContentIntent(pendingIntent)
                    .setDefaults(Notification.DEFAULT_SOUND);
            if (SDK_INT < JELLY_BEAN) {
                notification = builder.getNotification();
            } else {
                notification = builder.build();
            }
        }
        notificationManager.notify(0xDEAFBEEF, notification);
    }
}

②初始化了一个核心内部类对象，下面继续内部核心类分析跟踪过程

/**
 * Get BlockCanaryInternals singleton
 * 单例模式DCL
 * @return BlockCanaryInternals instance
 */
static BlockCanaryInternals getInstance() {
    if (sInstance == null) {
        synchronized (BlockCanaryInternals.class) {
            if (sInstance == null) {
                sInstance = new BlockCanaryInternals();
            }
        }
    }
    return sInstance;
}

4.内部核心类初始化过程:初始化堆栈采样器、初始化CPU采样器、初始化Printer、删除过期日志

public BlockCanaryInternals() {
        //初始化堆栈采样器①
        stackSampler = new StackSampler(
                Looper.getMainLooper().getThread(),
                sContext.provideDumpInterval());
        //初始化CPU采样器②
        cpuSampler = new CpuSampler(sContext.provideDumpInterval());
        //设置Printer③
        setMonitor(new LooperMonitor(new LooperMonitor.BlockListener() {

            @Override
            public void onBlockEvent(long realTimeStart, long realTimeEnd,
                                     long threadTimeStart, long threadTimeEnd) {
                // Get recent thread-stack entries and cpu usage
                ArrayList<String> threadStackEntries = stackSampler
                        .getThreadStackEntries(realTimeStart, realTimeEnd);
                if (!threadStackEntries.isEmpty()) {
                    BlockInfo blockInfo = BlockInfo.newInstance()
                            .setMainThreadTimeCost(realTimeStart, realTimeEnd, threadTimeStart, threadTimeEnd)
                            .setCpuBusyFlag(cpuSampler.isCpuBusy(realTimeStart, realTimeEnd))
                            .setRecentCpuRate(cpuSampler.getCpuRateInfo())
                            .setThreadStackEntries(threadStackEntries)
                            .flushString();
                    LogWriter.save(blockInfo.toString());

                    if (mInterceptorChain.size() != 0) {
                        for (BlockInterceptor interceptor : mInterceptorChain) {
                            interceptor.onBlock(getContext().provideContext(), blockInfo);
                        }
                    }
                }
            }
        }, getContext().provideBlockThreshold(), getContext().stopWhenDebugging()));
        //删除过期日志④
        LogWriter.cleanObsolete();
    }

④先从软柿子捏起，先看删除日志

/**
     * Delete obsolete log files, which is by default 2 days.
     */
    public static void cleanObsolete() {
        //写线程执行删除日志操作
        HandlerThreadFactory.getWriteLogThreadHandler().post(new Runnable() {
            @Override
            public void run() {
                long now = System.currentTimeMillis();
                //获取所有日志文件
                File[] f = BlockCanaryInternals.getLogFiles();
                if (f != null && f.length > 0) {
                    synchronized (SAVE_DELETE_LOCK) {
                        for (File aF : f) {
                            //如果日志大于2天则删除
                            if (now - aF.lastModified() > OBSOLETE_DURATION) {
                                aF.delete();
                            }
                        }
                    }
                }
            }
        });
    }

如何获取所有日志文件

/**
 * 获取日志存储路径
 * 根据用户设置的文件名称,如果SD卡未挂在或者不可写则使用/data目录,否则使用根目录+用户设置路径
 */
static String getPath() {
    String state = Environment.getExternalStorageState();
    String logPath = BlockCanaryInternals.getContext()
            == null ? "" : BlockCanaryInternals.getContext().providePath();

    if (Environment.MEDIA_MOUNTED.equals(state)
            && Environment.getExternalStorageDirectory().canWrite()) {
        return Environment.getExternalStorageDirectory().getPath() + logPath;
    }
    return getContext().provideContext().getFilesDir() + BlockCanaryInternals.getContext().providePath();
}
/**
 * 获取日志路径文件夹,如果不存在则创建
 */
static File detectedBlockDirectory() {
    File directory = new File(getPath());
    if (!directory.exists()) {
        directory.mkdirs();
    }
    return directory;
}
/**
 * 获取所有日志文件,过滤后缀.log的文件
 */
public static File[] getLogFiles() {
    File f = detectedBlockDirectory();
    if (f.exists() && f.isDirectory()) {
        return f.listFiles(new BlockLogFileFilter());
    }
    return null;
}

/**
 * 文件过滤器
 */
private static class BlockLogFileFilter implements FilenameFilter {

    private String TYPE = ".log";

    BlockLogFileFilter() {

    }

    @Override
    public boolean accept(File dir, String filename) {
        return filename.endsWith(TYPE);
    }
}

③采样器是对信息的收集，稍后分析，直接看设置Printer时新建出来的LooperMonitor对象

/**
 * 实现Printer接口必须实现println()方法
 */
class LooperMonitor implements Printer {
    //默认卡顿阙值
    private static final int DEFAULT_BLOCK_THRESHOLD_MILLIS = 3000;

    private long mBlockThresholdMillis = DEFAULT_BLOCK_THRESHOLD_MILLIS;
    private long mStartTimestamp = 0;
    private long mStartThreadTimestamp = 0;
    private BlockListener mBlockListener = null;
    private boolean mPrintingStarted = false;
    //Debug时是否进行卡顿检测
    private final boolean mStopWhenDebugging;

    public interface BlockListener {
        void onBlockEvent(long realStartTime,
                          long realTimeEnd,
                          long threadTimeStart,
                          long threadTimeEnd);
    }

    public LooperMonitor(BlockListener blockListener, long blockThresholdMillis, boolean stopWhenDebugging) {
        if (blockListener == null) {
            throw new IllegalArgumentException("blockListener should not be null.");
        }
        mBlockListener = blockListener;
        mBlockThresholdMillis = blockThresholdMillis;
        mStopWhenDebugging = stopWhenDebugging;
    }

    @Override
    public void println(String x) {
        //Debug时用户设置是否停止检测并且是否Debug
        if (mStopWhenDebugging && Debug.isDebuggerConnected()) {
            return;
        }
        //记录开始时间，也就是dispatchMessage之前的log打印时
        if (!mPrintingStarted) {
            mStartTimestamp = System.currentTimeMillis();
            mStartThreadTimestamp = SystemClock.currentThreadTimeMillis();
            mPrintingStarted = true;
            //启动采样器
            startDump();
        } else {
            //记录结束时间，也就是dispatchMessage之后的log打印时
            final long endTime = System.currentTimeMillis();
            mPrintingStarted = false;
            //判断是否卡顿
            if (isBlock(endTime)) {
                //发生卡顿，回调
                notifyBlockEvent(endTime);
            }
            stopDump();
        }
    }

    private boolean isBlock(long endTime) {
        return endTime - mStartTimestamp > mBlockThresholdMillis;
    }

    private void notifyBlockEvent(final long endTime) {
        final long startTime = mStartTimestamp;
        final long startThreadTime = mStartThreadTimestamp;
        final long endThreadTime = SystemClock.currentThreadTimeMillis();
        HandlerThreadFactory.getWriteLogThreadHandler().post(new Runnable() {
            @Override
            public void run() {
                mBlockListener.onBlockEvent(startTime, endTime, startThreadTime, endThreadTime);
            }
        });
    }

    private void startDump() {
        if (null != BlockCanaryInternals.getInstance().stackSampler) {
            BlockCanaryInternals.getInstance().stackSampler.start();
        }

        if (null != BlockCanaryInternals.getInstance().cpuSampler) {
            BlockCanaryInternals.getInstance().cpuSampler.start();
        }
    }

    private void stopDump() {
        if (null != BlockCanaryInternals.getInstance().stackSampler) {
            BlockCanaryInternals.getInstance().stackSampler.stop();
        }

        if (null != BlockCanaryInternals.getInstance().cpuSampler) {
            BlockCanaryInternals.getInstance().cpuSampler.stop();
        }
    }
}

回到③,在回调方法中，格式化了信息并写入文件中，启动拦截器

//设置Printer③
        setMonitor(new LooperMonitor(new LooperMonitor.BlockListener() {

            @Override
            public void onBlockEvent(long realTimeStart, long realTimeEnd,
                                     long threadTimeStart, long threadTimeEnd) {
                // Get recent thread-stack entries and cpu usage
                //获取堆栈信息
                ArrayList<String> threadStackEntries = stackSampler
                        .getThreadStackEntries(realTimeStart, realTimeEnd);
                if (!threadStackEntries.isEmpty()) {
                    BlockInfo blockInfo = BlockInfo.newInstance()
                            .setMainThreadTimeCost(realTimeStart, realTimeEnd, threadTimeStart, threadTimeEnd)
                            .setCpuBusyFlag(cpuSampler.isCpuBusy(realTimeStart, realTimeEnd))
                            .setRecentCpuRate(cpuSampler.getCpuRateInfo())
                            .setThreadStackEntries(threadStackEntries)
                            .flushString();
                    //写入日志
                    LogWriter.save(blockInfo.toString());
                    //启动拦截器
                    if (mInterceptorChain.size() != 0) {
                        for (BlockInterceptor interceptor : mInterceptorChain) {
                            interceptor.onBlock(getContext().provideContext(), blockInfo);
                        }
                    }
                }
            }
        }, getContext().provideBlockThreshold(), getContext().stopWhenDebugging()));

①②是采样器，主要对信息的收集，其中startDump方法会启动采样器，延迟执行，延迟时间就是卡顿的阙值乘以0.8。

/**
 * {@link AbstractSampler} sampler defines sampler work flow.
 */
abstract class AbstractSampler {

    private static final int DEFAULT_SAMPLE_INTERVAL = 300;

    protected AtomicBoolean mShouldSample = new AtomicBoolean(false);
    protected long mSampleInterval;

    private Runnable mRunnable = new Runnable() {
        @Override
        public void run() {
            doSample();

            if (mShouldSample.get()) {
                HandlerThreadFactory.getTimerThreadHandler()
                        .postDelayed(mRunnable, mSampleInterval);
            }
        }
    };

    public AbstractSampler(long sampleInterval) {
        if (0 == sampleInterval) {
            sampleInterval = DEFAULT_SAMPLE_INTERVAL;
        }
        mSampleInterval = sampleInterval;
    }

    public void start() {
        if (mShouldSample.get()) {
            return;
        }
        mShouldSample.set(true);
        //延迟执行，延迟时间是阙值的0.8倍
        HandlerThreadFactory.getTimerThreadHandler().removeCallbacks(mRunnable);
        HandlerThreadFactory.getTimerThreadHandler().postDelayed(mRunnable,
                BlockCanaryInternals.getInstance().getSampleDelay());
    }

    public void stop() {
        if (!mShouldSample.get()) {
            return;
        }
        mShouldSample.set(false);
        HandlerThreadFactory.getTimerThreadHandler().removeCallbacks(mRunnable);
    }

    abstract void doSample();
}

四、BlockCanary使用的设计模式有单例模式、外观模式、责任链模式。