一、網路狀態

       Android市場的逐漸降溫及形成穩定，其實說明了Android的發展走向穩重成熟的階段。

       除卻最開始的功能實現，到如今的使用者體驗至上，Android研發面臨的挑戰卻從未冷卻。基於大多數APP均是以APP為資料展示框架，實現客戶與伺服器資料互動，網路扮演了十分重要的角色。

       網路狀態，除了WiFi，資料，網路不可用等，還有網路條件不好等情形。存有標誌網路速度的則能較好地標示當前網路情形。

       以下則實現監聽網速，展示當前網速條件。藉由給客戶更好的使用者體驗。

二、實現監聽網速

TrafficStats類提供了以下方法，關於統計網速：

    /**
     * static long getMobileRxBytes()//獲取通過Mobile連線收到的位元組總數，但不包含WiFi static long
     * getMobileRxPackets()//獲取Mobile連線收到的資料包總數 static long
     * getMobileTxBytes()//Mobile傳送的總位元組數 static long
     * getMobileTxPackets()//Mobile傳送的總資料包數 static long
     * getTotalRxBytes()//獲取總的接受位元組數，包含Mobile和WiFi等 static long
     * getTotalRxPackets()//總的接受資料包數，包含Mobile和WiFi等 static long
     * getTotalTxBytes()//總的傳送位元組數，包含Mobile和WiFi等 static long
     * getTotalTxPackets()//傳送的總資料包數，包含Mobile和WiFi等 static long
     * getUidRxBytes(int uid)//獲取某個網路UID的接受位元組數 static long getUidTxBytes(int
     * uid) //獲取某個網路UID的傳送位元組數
     */
 

        建立浮動視窗，用於展示網速狀態；應用程式後臺執行，浮動視窗依舊顯示，則使用Service展示浮動視窗；在Activity中開啟Service。

網速監聽主體功能實現，TrafficBean.java：

package com.future.netobserverdemo.bean;

import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.net.TrafficStats;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 功能：流量Bean屬性資訊
 * 作者：vision
 * 時間：2016/10/19
 */
public class TrafficBean implements Serializable {
    /**
     * static long getMobileRxBytes()//獲取通過Mobile連線收到的位元組總數，但不包含WiFi static long
     * getMobileRxPackets()//獲取Mobile連線收到的資料包總數 static long
     * getMobileTxBytes()//Mobile傳送的總位元組數 static long
     * getMobileTxPackets()//Mobile傳送的總資料包數 static long
     * getTotalRxBytes()//獲取總的接受位元組數，包含Mobile和WiFi等 static long
     * getTotalRxPackets()//總的接受資料包數，包含Mobile和WiFi等 static long
     * getTotalTxBytes()//總的傳送位元組數，包含Mobile和WiFi等 static long
     * getTotalTxPackets()//傳送的總資料包數，包含Mobile和WiFi等 static long
     * getUidRxBytes(int uid)//獲取某個網路UID的接受位元組數 static long getUidTxBytes(int
     * uid) //獲取某個網路UID的傳送位元組數
     */

    /**
     * 不支援狀態【標識變數】
     */
    private static final int UNSUPPORT = -1;
    /**
     * 列印資訊標誌
     */
    private static final String TAG = "TrafficBean";
    /**
     * 當前物件例項
     */
    private static TrafficBean instance;
    /**
     * 當前應用的uid
     */
    static int UUID;
    /**
     * 上一次記錄網路位元組流
     */
    private long preRxBytes = 0;
    /**
     *
     */
    private Timer mTimer = null;
    /**
     * 上下文物件
     */
    private Context context;
    /**
     * 訊息處理器
     */
    private Handler handler;
    /**
     * 更新頻率
     */
    private final int UPDATE_FREQUENCY = 1;
    private int times = 1;


    /**
     * 構造方法
     *
     * @param context
     * @param handler
     * @param uid
     */
    public TrafficBean(Context context, Handler handler, int uid) {
        this.context = context;
        this.handler = handler;
        this.UUID = uid;
    }

    public TrafficBean(Context context, Handler handler) {
        this.context = context;
        this.handler = handler;
    }

    /**
     * 獲取例項物件
     *
     * @param context
     * @param handler
     * @return
     */
    public static TrafficBean getInstance(Context context, Handler handler) {
        if (instance == null) {
            instance = new TrafficBean(context, handler);
        }
        return instance;
    }

    /**
     * 獲取總流量
     *
     * @return
     */
    public long getTrafficInfo() {
        long recTraffic = UNSUPPORT;//下載流量
        long sendTraffic = UNSUPPORT;//上傳流量
        recTraffic = getRecTraffic();
        sendTraffic = getSendTraffic();

        if (recTraffic == UNSUPPORT || sendTraffic == UNSUPPORT) {
            return UNSUPPORT;
        } else {
            return recTraffic + sendTraffic;
        }
    }

    /**
     * 獲取上傳流量
     *
     * @return
     */
    private long getSendTraffic() {
        long sendTraffic = UNSUPPORT;
        sendTraffic = TrafficStats.getUidTxBytes(UUID);
        if (sendTraffic == UNSUPPORT) {
            return UNSUPPORT;
        }
        RandomAccessFile rafSend = null;
        String sndPath = "/proc/uid_stat/" + UUID + "/tcp_snd";
        try {
            rafSend = new RandomAccessFile(sndPath, "r");
            sendTraffic = Long.parseLong(rafSend.readLine());
        } catch (FileNotFoundException e) {
            Log.e(TAG, "FileNotFoundException: " + e.getMessage());
            sendTraffic = UNSUPPORT;
        } catch (IOException e) {
            Log.e(TAG, "IOException: " + e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                if (rafSend != null)
                    rafSend.close();
            } catch (IOException e) {
                Log.w(TAG, "Close RandomAccessFile exception: " + e.getMessage());
            }
        }
        return sendTraffic;
    }

    /**
     * 獲取下載流量
     * 某個應用的網路流量資料儲存在系統的
     * /proc/uid_stat/$UID/tcp_rcv | tcp_snd檔案中
     *
     * @return
     */
    private long getRecTraffic() {
        long recTraffic = UNSUPPORT;
        recTraffic = TrafficStats.getUidRxBytes(UUID);
        if (recTraffic == UNSUPPORT) {
            return UNSUPPORT;
        }
        Log.i(TAG, recTraffic + " ---1");
        //訪問資料檔案
        RandomAccessFile rafRec = null;
        String rcvPath = "/proc/uid_stat/" + UUID + "/tcp_rcv";
        try {
            rafRec = new RandomAccessFile(rcvPath, "r");
            recTraffic = Long.parseLong(rafRec.readLine()); // 讀取流量統計
        } catch (FileNotFoundException e) {
            Log.e(TAG, "FileNotFoundException: " + e.getMessage());
            recTraffic = UNSUPPORT;
        } catch (IOException e) {
            Log.e(TAG, "IOException: " + e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                if (rafRec != null)
                    rafRec.close();
            } catch (IOException e) {
                Log.w(TAG, "Close RandomAccessFile exception: " + e.getMessage());
            }
        }
        Log.i("test", recTraffic + "--2");
        return recTraffic;
    }


    /**
     * 獲取當前下載流量總和
     *
     * @return
     */
    public static long getNetworkRxBytes() {
        return TrafficStats.getTotalRxBytes();
    }

    /**
     * 獲取當前上傳流量總和
     *
     * @return
     */
    public static long getNetworkTxBytes() {
        return TrafficStats.getTotalTxBytes();
    }

    /**
     * 獲取當前網速
     *
     * @return
     */
    public double getNetSpeed() {
        long curRxBytes = getNetworkRxBytes();
        if (preRxBytes == 0)
            preRxBytes = curRxBytes;
        long bytes = curRxBytes - preRxBytes;
        preRxBytes = curRxBytes;
        //int kb = (int) Math.floor(bytes / 1024 + 0.5);
        double kb = (double) bytes / (double) 1024;
        BigDecimal bd = new BigDecimal(kb);

        return bd.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 開啟流量監控
     */
    public void startCalculateNetSpeed() {
        preRxBytes = getNetworkRxBytes();
        if (mTimer != null) {
            mTimer.cancel();
            mTimer = null;
        }
        if (mTimer == null) {
            mTimer = new Timer();
            mTimer.schedule(new TimerTask() {
                @Override
                public void run() {
                    if (times == UPDATE_FREQUENCY) {
                        Message msg = new Message();
                        msg.what = 1;
                        //msg.arg1 = getNetSpeed();
                        msg.obj = getNetSpeed();
                        handler.sendMessage(msg);
                        times = 1;
                    } else {
                        times++;
                    }
                }
            }, 1000, 1000);
        }
    }

    /**
     * 停止網速監聽計算
     */
    public void stopCalculateNetSpeed() {
        if (mTimer != null) {
            mTimer.cancel();
            mTimer = null;
        }
    }

    /**
     * 獲取當前應用uid
     *
     * @return
     */
    public int getUid() {
        try {
            PackageManager pm = context.getPackageManager();
            //修改
            ApplicationInfo ai = pm.getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
            return ai.uid;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return -1;
    }
}
 

public class ManagerService extends Service {
    private static final String TAG = "ManagerService";
    /**
     * 浮動窗口布局
     */
    private LinearLayout floatLL;
    public WindowManager.LayoutParams params;
    /**
     * 浮動串口布局引數
     */
    public WindowManager windowManager;
    public TextView floatTV;
    private ServiceBinder binder = new ServiceBinder();


    @Override
    public void onCreate() {
        super.onCreate();
        createFloatView();
    }

    /**
     * 建立浮動窗口布局
     */
    private void createFloatView() {
        params = new WindowManager.LayoutParams();
        windowManager = (WindowManager) getApplication().getSystemService(getApplication().WINDOW_SERVICE);
        params.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;// 設定window
        // type為TYPE_SYSTEM_ALERT
        params.format = PixelFormat.RGBA_8888;// 設定圖片格式，效果為背景透明
        params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;// 設定浮動視窗不可聚焦（實現操作除浮動視窗外的其他可見視窗的操作）
        params.gravity = Gravity.LEFT | Gravity.TOP;// 預設位置：左上角
        params.width = WidgetUtils.dpToPx(getApplicationContext(), 65);
        params.height = WindowManager.LayoutParams.WRAP_CONTENT;
        params.x = (WidgetUtils.getScreenWidth(getApplicationContext()) - params.width) / 2;// 設定x、y初始值，相對於gravity
        params.y = 10;
        // 獲取浮動視窗檢視所在佈局
        LayoutInflater inflater = LayoutInflater.from(getApplication());
        floatLL = (LinearLayout) inflater.inflate(R.layout.float_layout, null);
        windowManager.addView(floatLL, params);// 新增mFloatLayout
        floatTV = (TextView) floatLL.findViewById(R.id.move_desc);
        floatTV.measure(View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED), View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED));
        // 設定監聽浮動視窗的觸控移動
        floatTV.setOnTouchListener(new View.OnTouchListener() {

            @Override
            public boolean onTouch(View v, MotionEvent event) {
                // getRawX是觸控位置相對於螢幕的座標，getX是相對於按鈕的座標
                params.x = (int) event.getRawX() - floatTV.getMeasuredWidth() / 2;
                Log.i(TAG, "RawX" + event.getRawX());
                Log.i(TAG, "X" + event.getX());
                params.y = (int) event.getRawY() - floatTV.getMeasuredHeight() / 2 - 25;// 減25為狀態列的高度
                Log.i(TAG, "RawY" + event.getRawY());
                Log.i(TAG, "Y" + event.getY());
                windowManager.updateViewLayout(floatLL, params);// 重新整理
                return false; // 此處必須返回false，否則OnClickListener獲取不到監聽
            }
        });
        floatTV.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                Toast.makeText(getApplicationContext(), "浮動視窗被點選了！", Toast.LENGTH_SHORT).show();
            }
        });
    }


    public void setSpeed(String str) {
        floatTV.setText(str);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (floatLL != null && windowManager != null) {
            windowManager.removeView(floatLL);// 移除懸浮視窗
        }
        startService(new Intent(this, ManagerService.class));
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return START_STICKY_COMPATIBILITY;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }


    @Override
    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
    }

    public class ServiceBinder extends Binder {
        public ManagerService getService() {
            return ManagerService.this;
        }
    }
}

public class MainActivity extends AppCompatActivity {
    /**
     * Activity管理器
     */
    private ActivityManager activityManager;
    /**
     * 浮動圖示
     */
    private TextView moveDesc;
    /**
     * 訊息處理器
     */
    private Handler handler;
    /**
     * 流量資訊物件
     */
    private TrafficBean trafficBean;
    /**
     * 服務
     */
    private ManagerService service;
    /**
     * 標記資訊
     */
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
        moveDesc = (TextView) findViewById(R.id.tv);

        try {
            handler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    if (msg.what == 1) {
                        moveDesc.setText(msg.obj + "kb/s");
                        if (service != null) {
                            service.setSpeed(msg.obj + "kb/s");
                        }
                    }
                    super.handleMessage(msg);
                }
            };
            trafficBean = new TrafficBean(this, handler, 12580);
            trafficBean.startCalculateNetSpeed();
        } catch (Exception e) {
            e.printStackTrace();
        }

        Log.d(TAG, "總流量 = " + trafficBean.getTrafficInfo());
        Intent intent = new Intent(MainActivity.this, ManagerService.class);
        bindService(intent, conn, Context.BIND_AUTO_CREATE);
    }


    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder iBinder) {
            service = ((ManagerService.ServiceBinder) iBinder).getService();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            service = null;
        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        trafficBean.stopCalculateNetSpeed();
        unbindService(conn);
    }
}

三、細節注意

1，使用與建立對應，onCreate()中繫結，onDestory()中解綁；

2，清單檔案配置許可權及服務和廣播接收者。

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />

<service android:name="com.future.netobserverdemo.service.ManagerService" />

       <receiver android:name="com.future.netobserverdemo.service.ManagerReceiver">
            <intent-filter android:priority="2147483647"> <!-- 優先順序加最高 -->
                <!-- 系統啟動完成後會呼叫 -->
                <action android:name="android.intent.action.BOOT_COMPLETED" />
                <!-- 解鎖完成後會呼叫 -->
                <action android:name="android.intent.action.USER_PRESENT" />
                <!-- 監聽情景切換 -->
                <action android:name="android.media.RINGER_MODE_CHANGED" />
            </intent-filter>
        </receiver>

上班族如何安排時間才能每天都早起，讀書，跑步，冥想？