Android 網絡流量監聽開源項目-ConnectionClass源碼分析

很多App要做到極致的話，對網絡狀態的監聽是很有必要的，比如在網絡差的時候加載質量一般的小圖，縮略圖，在網絡好的時候，加載高清大圖，臉書的android 客戶端就是這么做的，

當然偉大的臉書也把這部分代碼開源出來，今天就來帶着大家分析一下臉書的這個開源代碼。

GitHub 地址https://github.com/facebook/network-connection-class

注意這個項目下載下來以后 會報很多錯誤，導致很多人運行不了，大家要根據各自電腦不同的情況修改gradle腳本，才能讓他運行。

如果有人對gradle不熟悉的話 可以下載我編寫好的gradle腳本 直接放在你項目的根目錄下即可。

地址在

http://pan.baidu.com/s/1pJuxesz

注意下載以后替換完成 把項目里為數不多的注解代碼給刪除即可正常運行，另外請自己查毒，中毒不要來找我~

 

下面來看下源碼，其實大部分的代碼還是很簡單的，

首先從MainActivity 代碼來看

 

 /**
     * AsyncTask for handling downloading and making calls to the timer.
     */
    private class DownloadImage extends AsyncTask<String, Void, Void> {

        @Override
        protected void onPreExecute() {
            mDeviceBandwidthSampler.startSampling();
            mRunningBar.setVisibility(View.VISIBLE);
        }

        @Override
        protected Void doInBackground(String... url) {
            String imageURL = url[0];
            try {
                // Open a stream to download the image from our URL.
                InputStream input = new URL(imageURL).openStream();
                try {
                    byte[] buffer = new byte[1024];

                    // Do some busy waiting while the stream is open.
                    while (input.read(buffer) != -1) {
                    }
                } finally {
                    input.close();
                }
            } catch (IOException e) {
                Log.e(TAG, "Error while downloading image.");
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void v) {
            mDeviceBandwidthSampler.stopSampling();
            // Retry for up to 10 times until we find a ConnectionClass.
            if (mConnectionClass == ConnectionQuality.UNKNOWN && mTries < 10) {
                mTries++;
                new DownloadImage().execute(mURL);
            }
            if (!mDeviceBandwidthSampler.isSampling()) {
                mRunningBar.setVisibility(View.GONE);
            }
        }
    }

主要就是通過上面的 這個task 來訪問一個網絡上的圖片，然后計算 “瞬時“流量。

然后到DeviceBandwidthSampler來看這個方法

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

這個lastTimeReading 實際上就代表這一次請求發起的時間，大家可以看到這里去了Samplinghandler，注意他是子線程的消息隊列~

private class SamplingHandler extends Handler {
        static final int MSG_START = 1;
        static final int MSG_STOP = 2;

        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;
                case MSG_STOP:
                    addFinalSample();
                    removeMessages(MSG_START);
                    break;
                default:
                    throw new IllegalArgumentException("Unknown what=" + msg.what);
            }
        }

看11-15行，實際上就是不斷的在調用add Sample這個函數，當我們那個DownloadTask 任務完成以后 就會發MSG_STOP消息。

然后addFinalSample 這個過程就完成了（即代表本次對網絡狀態的監聽完成）。

好，我們就來看看這個add Sample做了什么

/**
         * Method for polling for the change in total bytes since last update and
         * adding it to the BandwidthManager.
         */
        private void addSample() {
            long byteDiff = QTagParser.getInstance().parseDataUsageForUidAndTag(Process.myUid());
            synchronized (this) {
                long curTimeReading = SystemClock.elapsedRealtime();
                if (byteDiff != -1) {
                    mConnectionClassManager.addBandwidth(byteDiff, curTimeReading - mLastTimeReading);
                }
                mLastTimeReading = curTimeReading;
            }
        }

這邊代碼也很好理解，實際上第六航，byteDiff 就是代表 獲取了多少流量，單位是byte。

然后7-12行 就是用這個byteDiff 和你算出來的時間差，這2個值，來算你的瞬時網絡狀態。

第10行 就是算這個網絡狀態的，第10行的代碼 我不准備深入分析，因為這個是FACEBOOK對網絡狀態的定義，

大家在使用的時候 並不一定要按照他的來，比如他認為100k/s是網絡糟糕，但是我們4g網絡這么爛，可能50kb 就認為網絡很好了。所以這個地方代碼

以后有時間大家要根據自己的公司業務來調整。我們主要要看byteDiff 這個值是怎么算出來的，實際上這個才是代碼的精髓。

/**
     * Reads the qtaguid file and returns a difference from the previous read.
     *
     * @param uid The target uid to read bytes downloaded for.
     * @return The difference between the current number of bytes downloaded and
     */
    public long parseDataUsageForUidAndTag(int uid) {
        // The format of each line is
        // idx iface acct_tag_hex uid_tag_int cnt_set rx_bytes rx_packets tx_bytes
        // (There are many more fields but we are not interested in them)
        // For us parts: 1, 2, 3 are to see if the line is relevant
        // and part 5 is the received bytes
        // (part numbers start from 0)

        // Permit disk reads here, as /proc/net/xt_qtaguid/stats isn't really "on
        // disk" and should be fast.
        StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskReads();
        try {
            long tagRxBytes = 0;

            FileInputStream fis = new FileInputStream(mPath);
            //sStatsReader.setFileStream(fis);
            // writeFileToSD(sStatsReader);
            sStatsReader.setFileStream(fis);
            byte[] buffer = sLineBuffer.get();
            try {
                int length;
                sStatsReader.readLine(buffer);
                sStatsReader.skipLine(); // skip first line (headers)

                int line = 2;
                while ((length = sStatsReader.readLine(buffer)) != -1) {
                    try {

                        // Content is arranged in terms of:
                        // idx iface acct_tag_hex uid_tag_int cnt_set rx_bytes rx_packets tx_bytes tx_packets rx_tcp_bytes
                        // rx_tcp_packets rx_udp_bytes rx_udp_packets rx_other_bytes rx_other_packets tx_tcp_bytes tx_tcp_packets
                        // tx_udp_bytes tx_udp_packets tx_other_bytes tx_other_packets

                        // The ones we're interested in are:
                        // idx - ignore
                        // interface, filter out local interface ("lo")
                        // tag - ignore
                        // uid_tag_int, match it with the UID of interest
                        // cnt_set - ignore
                        // rx_bytes
                        //Log.v("burning", "buffer==" + new String(buffer));
                        sScanner.reset(buffer, length);
                        sScanner.useDelimiter(' ');

                        sScanner.skip();
                        if (sScanner.nextStringEquals("lo")) {
                            continue;
                        }
                        sScanner.skip();
                        if (sScanner.nextInt() != uid) {
                            continue;
                        }
                        sScanner.skip();
                        int rxBytes = sScanner.nextInt();
                        tagRxBytes += rxBytes;
                        line++;

                        // If the line is incorrectly formatted, ignore the line.
                    } catch (NumberFormatException e) {
                        Log.e(TAG, "Cannot parse byte count at line" + line + ".");
                        continue;
                    } catch (NoSuchElementException e) {
                        Log.e(TAG, "Invalid number of tokens on line " + line + ".");
                        continue;
                    }
                }
            } finally {
                fis.close();
            }

            if (sPreviousBytes == -1) {
                sPreviousBytes = tagRxBytes;
                return -1;
            }
            long diff = tagRxBytes - sPreviousBytes;
            sPreviousBytes = tagRxBytes;
            return diff;

        } catch (IOException e) {
            Log.e(TAG, "Error reading from /proc/net/xt_qtaguid/stats. Please check if this file exists.");
        } finally {
            StrictMode.setThreadPolicy(savedPolicy);
        }

        // Return -1 upon error.
        return -1;
    }

17行-21行，實際上就是對/proc/net/xt_qtaguid/stats 這個文件進行讀取，然后分析他的內容 來算出來我們的bytediff的，

熟悉linux的同學 尤其是運維的同學 肯定對/proc/net 不陌生，后面的xt_qtaguid/stats這個路徑實際上就是谷歌android

給我們特殊的一個監聽網絡狀態的接口文件。我這里可以給出一部分日志的結構 供大家參考。因為這個函數的內容就是對

這個日志的解析，你能讀懂這個日志 就讀懂了 這個開源項目最核心的部分。

 

 

idx哪一行就代表着文件頭，下面對應的就是數據。

可以看到iface就代表着 那個網絡接口，因為我是wifi下運行的這個代碼 所以肯定是wlan，acct_tag_hex 這個標記就代表socket  當然這些參數值都不重要。

uid_tag_int 這個值 是比較重要的，很多人不明白為什么這個函數一定要先判斷下uid的值，大家在這里一定要注意，對於linux系統來說 uid 就代表用戶。

而android 是單用戶系統，谷歌把這個地方改造成了uid代表你的app！！！！！！！！！！！！！！所以我們在監聽app網絡狀態的時候 你一定要判斷uid

你不能把別的app的流量也算在你自己的頭上！

然后看cnt_set 實際上着就是一個標志位 0代表前台流量 1代表后台流量罷了。然后看rx_bytes r就代表是receive tx_bytes就代表transmit所以

就代表着 一個是收到的byte 一個是發送的byte，對於手機來說 發送的byte一般較少，我們主要關心的就是收到的byte。

好，分析完畢以后 我們再接着看那個函數 就比較容易了。

第29行 就是跳過文件頭，因為我們的目標是獲取rx_bytes

56行 就是看如果不是自己的app 的流量 自然跳出 不會計算。

77-83行，就是算bytediff的，注意那個sPreviousBytes 這個就是存儲你上一次的流量的，初始化的時候是-1

他是一個靜態變量，

因為我們的日志里面 rx_bytes是存儲的總流量！，所以這邊計算的時候要用流量差 來表示bytediff。

 

到這 這個框架就分析完畢了，希望能帶給大家一點啟發，

最后有的人可能要問 為什么 那個while循環 要把rx_bytes 給加起來，因為大家要注意啊 一個app

可能有多個進程啊，我們要計算自己的app 或者某個app的 網絡狀態，肯定是要把他所有進程的

流量全算進去的！所以這個地方要不斷遍歷！此外就是如果你真的能讀懂我的這篇博客的話，又恰好會python的

話，就可以用python和adb 來完成對你手機上app的流量測試了！很方便，再也不用裝什么360來測試你app

的流量了！

 

人生苦短，何不用python！