开源框架源码分析：网速监听—facebook/network-connection-class

前言

上一篇跟大家推荐了一个监听网速的开源框架，所以就研究了一下开源的代码，没想到会这么简单，原本以为要多看一阵才能写出来，所以今天我们就来聊聊facebook/network-connection-class的源码。

正文

源码连接：https://github.com/facebook/network-connection-class/

我们从github上直接下载zip，然后引入到Android studio中，就可以看到源码了。

概览

一打开源码，卧槽槽，就这5个类，还有一个是暂时不用的（ByteArrayScanner），所以我们就先来简单的看看每个类都有什么作用。

ByteArrayScanner ：这个类暂时没有用，从源码来看，他里面全是工具类方法，例如从数组中找到某一个字符，得到某个字符的索引之类的。

ConnectionQuality：一个枚举类，里面返回不同的网络等级。

ExponentialGeometricAverage：主要是获取网络的平均值，里面最重要的就是addMeasurement(double measurement)。

DeviceBandwidthSampler：很重要的类，网络的检测相关的流程都在里面。

ConnectionClassManager：最重要的类，一些主要的api还有监听要通过他来获取。

分析

因为类很少，所以我们就先整体看了一眼，但是还不知道他们之间的关系，所以现在我们还要根据使用流程从头分析一遍，加深一下对他们的理解。

首先我们要绑定监听：

ConnectionClassManager.getInstance().register(mListener);

所以我们先去看看register方法：

private ArrayList<ConnectionClassStateChangeListener> mListenerList =
      new ArrayList<ConnectionClassStateChangeListener>();

/**
   * Method for adding new listeners to this class.
   * @param listener {@link ConnectionClassStateChangeListener} to add as a listener.
   */
  public ConnectionQuality register(ConnectionClassStateChangeListener listener) {
    if (listener != null) {
      mListenerList.add(listener);
    }
    return mCurrentBandwidthConnectionQuality.get();
  }

源码很简单，就把监听listener放到数组里，返回当前的网络状态。

然后调用：

DeviceBandwidthSampler.getInstance().startSampling();

这个时候重点就来了：

/**
   * Method call to start sampling for download bandwidth.
   */
  public void startSampling() {
    if (mSamplingCounter.getAndIncrement() == 0) {
      mHandler.startSamplingThread();
      mLastTimeReading = SystemClock.elapsedRealtime();
    }
  }

首先源码先进行判断当前的监听状态，否则是不开启网络监听的，mLastTimeReading得到一个相对的时间戳，用来计算网速，所以接下来要去看看 mHandler.startSamplingThread()：

private class SamplingHandler extends Handler {
      /**
       * Time between polls in ms.
       */
      static final long SAMPLE_TIME = 1000;

      static private final int MSG_START = 1;

      public SamplingHandler(Looper looper) {
          super(looper);
      }

      @Override
      public void handleMessage(Message msg) {
          switch (msg.what) {
              case MSG_START:
                  // 把样本添加进来计算网速
                  addSample();
                  // 循环获取样本计算网速
                  sendEmptyMessageDelayed(MSG_START, SAMPLE_TIME);
                  break;
              default:
                  throw new IllegalArgumentException("Unknown what=" + msg.what);
          }
      }

      /**
       * 开启网络监听的循环
       * */
      public void startSamplingThread() {
          sendEmptyMessage(SamplingHandler.MSG_START);
      }

      /**
       * 停止网络监听的循环
       * */
      public void stopSamplingThread() {
          removeMessages(SamplingHandler.MSG_START);
      }
  }

上面的代码是SamplingHandler的源码，里面主要是通过handlermessage来实现一个循环机制，每一次都把网络的样本添加进来，然后去计算当前的网速，handler通过发送message来实现循环，例如播放器的时间更新等等，这种 用法简直不能再常见了，接下来核心要分析的就是addSample（），看看到底是怎么计算网速的：

/**
   * Method for polling for the change in total bytes since last update and
   * adding it to the BandwidthManager.
   */
  protected void addSample() {
      // 获取手机总下载量
    long newBytes = TrafficStats.getTotalRxBytes();
      // 用总下载量减去上一次计算的总下载量，就得到了在循环间隔内下载的数据量
    long byteDiff = newBytes - sPreviousBytes;
      // 如果是第一次，不进行计算
    if (sPreviousBytes >= 0) {
      synchronized (this) {
          // 获取当前的时间戳
        long curTimeReading = SystemClock.elapsedRealtime();
          // 还记得之前的startSampling获取的相对时间戳吗，这里得到时间的差值
        mConnectionClassManager.addBandwidth(byteDiff, curTimeReading - mLastTimeReading);
        // 更新相对的时间戳
        mLastTimeReading = curTimeReading;
      }
    }
    // 更新上一次的总下载量
    sPreviousBytes = newBytes;
  }

为了方便理解，我把每一句都写了注释，TrafficStats.getTotalRxBytes()这个api我之前是没接触过，所以看一下源码的注释是怎么解释的：

/**
     * Return number of bytes received since device boot. Counts packets across
     * all network interfaces, and always increases monotonically since device
     * boot. Statistics are measured at the network layer, so they include both
     * TCP and UDP usage.
     * <p>
     * Before {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, this may
     * return {@link #UNSUPPORTED} on devices where statistics aren't available.
     */
    public static long getTotalRxBytes() {
        return nativeGetTotalStat(TYPE_RX_BYTES);
    }

大概意思返回手机从开机开始通过网络的数据下载量，相信做系统开发是网络相关开发的朋友应该很熟悉这个api。

再回到之前的源码，我们要去分析mConnectionClassManager.addBandwidth（）把下载量的差值和时间差都作为参数传进去都做了哪些操作：

/**
   * Adds bandwidth to the current filtered latency counter. Sends a broadcast to all
   * {@link ConnectionClassStateChangeListener} if the counter moves from one bucket
   * to another (i.e. poor bandwidth -> moderate bandwidth).
   */
  public synchronized void addBandwidth(long bytes, long timeInMs) {

    //Ignore garbage values.
    if (timeInMs == 0 || (bytes) * 1.0 / (timeInMs) * BYTES_TO_BITS < BANDWIDTH_LOWER_BOUND) {
      return;
    }
    // 先把下载量的单位转换成比特
    double bandwidth = (bytes) * 1.0 / (timeInMs) * BYTES_TO_BITS;
    // 开始测量网速
    mDownloadBandwidth.addMeasurement(bandwidth);
    // 是否初始值已经发生了变化，否则不去相应我们绑定的listener
    if (mInitiateStateChange) {
      // 样本采集数+1
      mSampleCounter += 1;
      // 如果计算出来的网速与上一个网速不同
      if (getCurrentBandwidthQuality() != mNextBandwidthConnectionQuality.get()) {
        // 重新开始计算网速
        mInitiateStateChange = false;
        mSampleCounter = 1;
      }
      // 如果计算数已经大于标准计算次数 且 与 记录的网速的峰值和最低值对比，如果大于峰值，或者小于最低值，说明网络已经发生变化
      if (mSampleCounter >= DEFAULT_SAMPLES_TO_QUALITY_CHANGE  && significantlyOutsideCurrentBand()) {
        // 重新开始计算网速
        mInitiateStateChange = false;
        mSampleCounter = 1;
        // 记录新的网速
        mCurrentBandwidthConnectionQuality.set(mNextBandwidthConnectionQuality.get());
        // 回调所有的监听listener
        notifyListeners();
      }
      return;
    }
    // 如果现在的网速与计算出来的网速不同
    if (mCurrentBandwidthConnectionQuality.get() != getCurrentBandwidthQuality()) {
      // 初始值已经发生了变化
      mInitiateStateChange = true;
      // 记录新的网速
      mNextBandwidthConnectionQuality =
          new AtomicReference<ConnectionQuality>(getCurrentBandwidthQuality());
    }
  }

代码稍微有点长，而且因为代码顺序的问题可能会影响我们的理解，首先 mDownloadBandwidth.addMeasurement(bandwidth) 里面的算法我是没看懂就不跟大家吹了，反正就是计算网速，因为mInitiateStateChange默认是false，所以会直接记录网速，下一次才会去对比网速，如果发生了变化再去记录网速，如果5（默认是5）次计算都是相同的网速，并且跟之前记录的网速做对比，如果平均值大于记录网速的峰值，或者小于记录网速的最低值，则回调所有的网络监听listener。

刚才分别调用了：

mDownloadBandwidth.addMeasurement(bandwidth)：计算网速
getCurrentBandwidthQuality ： 根据addMeasurement计算出来的网速，得到对应的ConnectionQuality值。
significantlyOutsideCurrentBand ：对比计算的网速和记录的网速的峰值或最低值，判断是否要更新网络状态并且回调listener。
notifyListeners ： 回调所有的listener。

这些代码有点多，我就不贴出来，除了mDownloadBandwidth.addMeasurement(bandwidth)这个计算方法我不懂（数学实在一般般），其他的都很好理解，大家自己去看吧。

ok，这样一个完整的网速监听到回调listener的流程就结束了，之后就是继续循环，直到：

DeviceBandwidthSampler.getInstance().stopSampling();

public void stopSampling() {
    if (mSamplingCounter.decrementAndGet() == 0) {
      mHandler.stopSamplingThread();
      addFinalSample();
    }
  }

/**
   * Resets previously read byte count after recording a sample, so that
   * we don't count bytes downloaded in between sampling sessions.
   */
  protected void addFinalSample() {
    addSample();
    sPreviousBytes = -1;
  }

stop的时候就重置了sPreviousBytes，handler不再循环下去。

ConnectionClassManager.getInstance().remove(mListener);

千万别忘记在不需要监听的时候解绑listener，否则会出现内存问题。

里面还有一些不常用的类和api，大家可以自己去百度学习了解一下。

总结

到这里就结束了，我感觉这个框架特别适合刚开始看框架源码的朋友，因为类比较少，并且流程也是很简单的，作为一个入门的学习非常棒，而且还了解了一些平时没接触接触过的api，一举两得。

ok，那就拜拜了，有好的东西再跟大家一起分享。