萬盛學電腦網

您现在的位置: 萬盛學電腦網 >> 程式設計 >  >> 網路程式設計 >> Android 開發

Android 流量監控與統計實作指南

Android 網路流量統計機制

Android 提供 TrafficStats (API 8+) 和 NetworkStatsManager (API 23+) 兩套 API 取得網路流量統計。前者輕量、全域統計;後者詳細、支援 UID/網路介面/標籤分類、需權限。

TrafficStats:輕量全域統計 (API 8+)


public class TrafficStatsHelper {
    /** 取得總接收位元組數 (含 Wi-Fi、行動網路、所有 UID) */
    public static long getTotalRxBytes() {
        return TrafficStats.getTotalRxBytes();
    }
    
    /** 取得總傳送位元組數 */
    public static long getTotalTxBytes() {
        return TrafficStats.getTotalTxBytes();
    }
    
    /** 取得特定 UID (應用) 的接收位元組 */
    public static long getUidRxBytes(int uid) {
        return TrafficStats.getUidRxBytes(uid);
    }
    
    /** 取得特定 UID 的傳送位元組 */
    public static long getUidTxBytes(int uid) {
        return TrafficStats.getUidTxBytes(uid);
    }
    
    /** 取得特定網路介面統計 (如 "wlan0", "rmnet0") */
    public static long getInterfaceRxBytes(String iface) {
        try {
            return TrafficStats.getInterfaceRxBytes(iface);
        } catch (UnsupportedOperationException e) {
            return -1; // 部分裝置不支援
        }
    }
    
    /** 設定執行緒流量標籤 (統計特定邏輯流量) */
    public static void tagSocket(int tag) {
        TrafficStats.setThreadStatsTag(tag);
    }
    
    public static void untagSocket() {
        TrafficStats.clearThreadStatsTag();
    }
    
    /** 取得標籤統計 */
    public static long getTagRxBytes(int tag) {
        return TrafficStats.getThreadStatsTag() == tag ? TrafficStats.getUidRxBytes(Process.myUid()) : -1;
    }
}

NetworkStatsManager:詳細統計 (API 23+)

需權限:android.permission.READ_NETWORK_USAGE_HISTORY (普通權限,安裝時授予)


public class NetworkStatsHelper {
    private static final String TAG = "NetworkStatsHelper";
    private final NetworkStatsManager statsManager;
    private final Context context;

    public NetworkStatsHelper(Context context) {
        this.context = context;
        this.statsManager = (NetworkStatsManager) context.getSystemService(Context.NETWORK_STATS_SERVICE);
    }

    /** 查詢特定 UID 在時間範圍內的流量 */
    public void queryUidStats(int uid, long startTime, long endTime, OnStatsResultListener listener) {
        Executors.newSingleThreadExecutor().execute(() -> {
            try {
                NetworkStats.Bucket bucket = queryUidBucket(uid, startTime, endTime);
                long rxBytes = bucket != null ? bucket.getRxBytes() : 0;
                long txBytes = bucket != null ? bucket.getTxBytes() : 0;
                
                new Handler(Looper.getMainLooper()).post(() -> 
                    listener.onResult(rxBytes, txBytes, bucket));
            } catch (Exception e) {
                Log.e(TAG, "Query failed", e);
                new Handler(Looper.getMainLooper()).post(() -> listener.onError(e));
            }
        });
    }

    private NetworkStats.Bucket queryUidBucket(int uid, long start, long end) {
        NetworkStats query = statsManager.querySummaryForDevice(
            ConnectivityManager.TYPE_WIFI, "", start, end); // 或 TYPE_MOBILE
        
        // 實際上需用 queryDetailsForUid 取得特定 UID
        NetworkStats details = statsManager.queryDetailsForUid(
            ConnectivityManager.TYPE_WIFI, "", start, end, uid);
        
        NetworkStats.Bucket bucket = new NetworkStats.Bucket();
        while (details.hasNextBucket()) {
            details.getNextBucket(bucket);
            // 累加多個 bucket (可能跨多個時間桶)
        }
        details.close();
        return bucket;
    }

    /** 查詢所有應用流量排行 (需系統應用或特殊權限) */
    public List queryAllAppsUsage(long start, long end) {
        // 需 PACKAGE_USAGE_STATS 權限 (用戶在設定中授予)
        // 通常用於系統應用或 MDM 方案
        return Collections.emptyList();
    }

    public interface OnStatsResultListener {
        void onResult(long rxBytes, long txBytes, NetworkStats.Bucket bucket);
        void onError(Exception e);
    }
}

應用層流量監控:VpnService 方案 (無需 Root)

實作 VpnService 可攔截所有應用流量,實現逐應用、逐連線統計:


public class TrafficVpnService extends VpnService {
    private static final String TAG = "TrafficVpnService";
    private Thread vpnThread;
    private ParcelFileDescriptor vpnInterface;
    private boolean running = false;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (running) return START_STICKY;
        
        // 建立 VPN 介面
        Builder builder = new Builder();
        builder.setSession("TrafficMonitor")
               .addAddress("10.0.0.1", 24) // 虛擬 IP
               .addRoute("0.0.0.0", 0)     // 攔截所有流量
               .addDnsServer("8.8.8.8")
               .setBlocking(true);
        
        vpnInterface = builder.establish();
        running = true;
        
        vpnThread = new Thread(this::runVpnLoop, "VpnThread");
        vpnThread.start();
        
        // 建立前台服務通知 (Android 8+ 必須)
        startForeground(1, buildNotification());
        return START_STICKY;
    }

    private void runVpnLoop() {
        FileInputStream in = new FileInputStream(vpnInterface.getFileDescriptor());
        FileOutputStream out = new FileOutputStream(vpnInterface.getFileDescriptor());
        
        // 簡化:實際需解析 IP/TCP/UDP 封包,提取 UID (透過 SO_MARK 或 xt_owner)
        // Android 使用 fwmark 標記 UID,需配合 iptables 或 libnetfilter
        // 這裡僅示意架構
        byte[] packet = new byte[32767];
        while (running) {
            try {
                int len = in.read(packet);
                if (len > 0) {
                    // 解析封包,提取 UID、協議、連接四元組
                    // 統計位元組數
                    // 轉發封包至真實網路 (需建立真實 socket 連線)
                }
            } catch (IOException e) {
                if (running) Log.e(TAG, "VPN read error", e);
            }
        }
    }

    @Override
    public void onDestroy() {
        running = false;
        try { vpnInterface?.close(); } catch (IOException ignored) {}
        super.onDestroy();
    }
}

注意:完整 VpnService 實作極其複雜 (需處理 TCP 狀態機、UDP 映射、DNS、IPv6、分流、效能)。生產環境建議使用成熟庫:libreVPN、ToyVpn (範例)、PersonalDNSFilter。

流量統計 UI 實作:即時速度顯示


public class SpeedMonitor {
    private static final long UPDATE_INTERVAL_MS = 1000;
    private final Handler handler = new Handler(Looper.getMainLooper());
    private final TrafficStatsHelper statsHelper = new TrafficStatsHelper();
    private long lastRx = -1, lastTx = -1;
    private long lastTime = -1;
    private OnSpeedUpdateListener listener;
    private Runnable updateRunnable = new Runnable() {
        @Override public void run() {
            updateSpeed();
            if (listener != null) handler.postDelayed(this, UPDATE_INTERVAL_MS);
        }
    };

    public void start(OnSpeedUpdateListener listener) {
        this.listener = listener;
        lastRx = TrafficStats.getTotalRxBytes();
        lastTx = TrafficStats.getTotalTxBytes();
        lastTime = SystemClock.elapsedRealtime();
        handler.post(updateRunnable);
    }

    public void stop() {
        handler.removeCallbacks(updateRunnable);
        listener = null;
    }

    private void updateSpeed() {
        long now = SystemClock.elapsedRealtime();
        long currentRx = TrafficStats.getTotalRxBytes();
        long currentTx = TrafficStats.getTotalTxBytes();
        
        long deltaTime = now - lastTime;
        if (deltaTime > 0) {
            long rxSpeed = (currentRx - lastRx) * 1000 / deltaTime; // bytes/sec
            long txSpeed = (currentTx - lastTx) * 1000 / deltaTime;
            
            lastRx = currentRx;
            lastTx = currentTx;
            lastTime = now;
            
            if (listener != null) {
                listener.onSpeedUpdate(rxSpeed, txSpeed);
            }
        }
    }

    public interface OnSpeedUpdateListener {
        void onSpeedUpdate(long rxBytesPerSec, long txBytesPerSec);
    }
}

// 格式化顯示
public class FormatUtils {
    public static String formatSpeed(long bytesPerSec) {
        if (bytesPerSec < 1024) return bytesPerSec + " B/s";
        if (bytesPerSec < 1024 * 1024) return String.format(Locale.getDefault(), "%.1f KB/s", bytesPerSec / 1024.0);
        return String.format(Locale.getDefault(), "%.1f MB/s", bytesPerSec / (1024.0 * 1024));
    }
    
    public static String formatTotal(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format(Locale.getDefault(), "%.2f KB", bytes / 1024.0);
        if (bytes < 1024 * 1024 * 1024) return String.format(Locale.getDefault(), "%.2f MB", bytes / (1024.0 * 1024));
        return String.format(Locale.getDefault(), "%.2f GB", bytes / (1024.0 * 1024 * 1024));
    }
}

流量限額提醒與配額管理


public class DataUsageManager {
    private static final String PREFS_NAME = "data_usage_prefs";
    private static final String KEY_MONTHLY_LIMIT = "monthly_limit_bytes";
    private static final String KEY_WARNING_THRESHOLD = "warning_threshold_percent"; // 0-100
    private static final String KEY_CYCLE_START_DAY = "cycle_start_day"; // 1-28
    private static final String KEY_LAST_ALERT_LEVEL = "last_alert_level";
    
    private final SharedPreferences prefs;
    private final TrafficStatsHelper statsHelper;

    public DataUsageManager(Context context) {
        this.prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
        this.statsHelper = new TrafficStatsHelper();
    }

    public void setMonthlyLimit(long bytes) {
        prefs.edit().putLong(KEY_MONTHLY_LIMIT, bytes).apply();
    }

    public void setWarningThreshold(int percent) {
        prefs.edit().putInt(KEY_WARNING_THRESHOLD, Math.max(0, Math.min(100, percent))).apply();
    }

    public void setBillingCycleStartDay(int day) {
        prefs.edit().putInt(KEY_CYCLE_START_DAY, Math.max(1, Math.min(28, day))).apply();
    }

    /** 檢查並發送提醒 (在 WorkManager 週期性任務中呼叫) */
    public void checkAndAlert(Context context) {
        long limit = prefs.getLong(KEY_MONTHLY_LIMIT, -1);
        if (limit <= 0) return; // 未設定限額
        
        int threshold = prefs.getInt(KEY_WARNING_THRESHOLD, 80);
        int cycleStartDay = prefs.getInt(KEY_CYCLE_START_DAY, 1);
        
        // 計算當前計費週期起始時間
        long cycleStart = getCurrentCycleStart(cycleStartDay);
        long used = statsHelper.getUidRxBytes(Process.myUid()) + statsHelper.getUidTxBytes(Process.myUid());
        // 注意:TrafficStats 重開機會歸零,生產環境需持久化基準值
        
        int percent = (int) ((used * 100) / limit);
        int lastAlert = prefs.getInt(KEY_LAST_ALERT_LEVEL, -1);
        
        if (percent >= threshold && percent > lastAlert) {
            // 發送通知
            sendUsageAlert(context, percent, used, limit);
            prefs.edit().putInt(KEY_LAST_ALERT_LEVEL, percent).apply();
        } else if (percent < threshold) {
            // 使用率回落,重置提醒等級
            prefs.edit().putInt(KEY_LAST_ALERT_LEVEL, -1).apply();
        }
    }

    private long getCurrentCycleStart(int dayOfMonth) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, dayOfMonth);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        
        if (cal.getTimeInMillis() > System.currentTimeMillis()) {
            cal.add(Calendar.MONTH, -1);
        }
        return cal.getTimeInMillis();
    }

    private void sendUsageAlert(Context context, int percent, long used, long limit) {
        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, "data_usage_channel")
            .setSmallIcon(R.drawable.ic_data_warning)
            .setContentTitle("流量使用提醒")
            .setContentText(String.format("已使用 %d%% (%s / %s)", percent, 
                FormatUtils.formatTotal(used), FormatUtils.formatTotal(limit)))
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .setAutoCancel(true);
        
        NotificationManagerCompat.from(context).notify(1002, builder.build());
    }
}

權限與隱私合規

  • READ_NETWORK_USAGE_HISTORY:API 23+ 普通權限,讀取 NetworkStatsManager
  • PACKAGE_USAGE_STATS:特殊權限,需使用者在設定「應用使用情況存取權」中授予,用於查詢所有應用流量
  • VpnService:需使用者明確授權 VPN 介面,系統會顯示確認對話框
  • 資料最小化:僅統計必要指標,避免記錄具體域名/內容 (除非用戶明確同意)
  • 本地處理:流量統計建議純本地計算,不上傳伺服器

總結

Android 流量監控分層選擇:

  • 簡單自我統計:TrafficStats + 定時輪詢,零權限、極簡實作
  • 詳細歷史/分類統計:NetworkStatsManager + READ_NETWORK_USAGE_HISTORY
  • 全系統/逐應用/逐連線監控:VpnService (複雜、耗電、需用戶信任)
  • 企業/家長控制:Device Policy Controller (DPC) + NetworkLogging

關鍵提醒:TrafficStats 重開機歸零,長期統計必須自行持久化基準值;VpnService 實作難度高,優先評估現有開源方案。

copyright © 萬盛學電腦網 all rights reserved