Migration to TrafficStats. (1719a39a) · Commits · e / os / android_frameworks_base

core/java/android/content/AbstractThreadedSyncAdapter.java

+6 −6

Original line number	Diff line number	Diff line
		@@ -17,10 +17,10 @@
		package android.content;

		import android.accounts.Account;
		import android.net.TrafficStats;
		import android.os.Bundle;
		import android.os.Process;
		import android.os.NetStat;
		import android.os.IBinder;
		import android.os.Process;
		import android.os.RemoteException;
		import android.util.EventLog;

		@@ -157,8 +157,8 @@ public abstract class AbstractThreadedSyncAdapter {

		SyncResult syncResult = new SyncResult();
		int uid = Process.myUid();
		mInitialTxBytes = NetStat.getUidTxBytes(uid);
		mInitialRxBytes = NetStat.getUidRxBytes(uid);
		mInitialTxBytes = TrafficStats.getUidTxBytes(uid);
		mInitialRxBytes = TrafficStats.getUidRxBytes(uid);
		ContentProviderClient provider = null;
		try {
		provider = mContext.getContentResolver().acquireContentProviderClient(mAuthority);
		@@ -175,8 +175,8 @@ public abstract class AbstractThreadedSyncAdapter {
		if (!isCanceled()) {
		mSyncContext.onFinished(syncResult);
		}
		onLogSyncDetails(NetStat.getUidTxBytes(uid) - mInitialTxBytes,
		NetStat.getUidRxBytes(uid) - mInitialRxBytes, syncResult);
		onLogSyncDetails(TrafficStats.getUidTxBytes(uid) - mInitialTxBytes,
		TrafficStats.getUidRxBytes(uid) - mInitialRxBytes, syncResult);
		// synchronize so that the assignment will be seen by other threads
		// that also synchronize accesses to mSyncThread
		synchronized (mSyncThreadLock) {

core/java/android/content/TempProviderSyncAdapter.java

+10 −10

Original line number	Diff line number	Diff line
		package android.content;

		import android.accounts.Account;
		import android.accounts.AuthenticatorException;
		import android.accounts.OperationCanceledException;
		import android.database.SQLException;
		import android.net.TrafficStats;
		import android.os.Bundle;
		import android.os.Debug;
		import android.os.NetStat;
		import android.os.Parcelable;
		import android.os.Process;
		import android.os.SystemProperties;
		@@ -12,9 +15,6 @@ import android.util.Config;
		import android.util.EventLog;
		import android.util.Log;
		import android.util.TimingLogger;
		import android.accounts.Account;
		import android.accounts.AuthenticatorException;
		import android.accounts.OperationCanceledException;

		import java.io.IOException;

		@@ -203,8 +203,8 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter {
		if (mProviderSyncStarted) mProvider.onSyncCanceled();
		// We may lose the last few sync events when canceling. Oh well.
		int uid = Process.myUid();
		logSyncDetails(NetStat.getUidTxBytes(uid) - mInitialTxBytes,
		NetStat.getUidRxBytes(uid) - mInitialRxBytes, mResult);
		logSyncDetails(TrafficStats.getUidTxBytes(uid) - mInitialTxBytes,
		TrafficStats.getUidRxBytes(uid) - mInitialRxBytes, mResult);
		}

		@Override
		@@ -212,8 +212,8 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter {
		Process.setThreadPriority(Process.myTid(),
		Process.THREAD_PRIORITY_BACKGROUND);
		int uid = Process.myUid();
		mInitialTxBytes = NetStat.getUidTxBytes(uid);
		mInitialRxBytes = NetStat.getUidRxBytes(uid);
		mInitialTxBytes = TrafficStats.getUidTxBytes(uid);
		mInitialRxBytes = TrafficStats.getUidRxBytes(uid);
		try {
		sync(mSyncContext, mAccount, mAuthority, mExtras);
		} catch (SQLException e) {
		@@ -222,8 +222,8 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter {
		} finally {
		mSyncThread = null;
		if (!mIsCanceled) {
		logSyncDetails(NetStat.getUidTxBytes(uid) - mInitialTxBytes,
		NetStat.getUidRxBytes(uid) - mInitialRxBytes, mResult);
		logSyncDetails(TrafficStats.getUidTxBytes(uid) - mInitialTxBytes,
		TrafficStats.getUidRxBytes(uid) - mInitialRxBytes, mResult);
		mSyncContext.onFinished(mResult);
		}
		}

core/java/android/os/NetStat.java

deleted100644 → 0

+0 −247

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package android.os;

		import android.util.Log;

		import java.io.File;
		import java.io.RandomAccessFile;
		import java.io.IOException;

		/** @hide */
		public class NetStat {

		// Logging tag.
		private final static String TAG = "netstat";

		// We pre-create all the File objects so we don't spend a lot of
		// CPU at runtime converting from Java Strings to byte[] for the
		// kernel calls.
		private final static File[] MOBILE_TX_PACKETS = mobileFiles("tx_packets");
		private final static File[] MOBILE_RX_PACKETS = mobileFiles("rx_packets");
		private final static File[] MOBILE_TX_BYTES = mobileFiles("tx_bytes");
		private final static File[] MOBILE_RX_BYTES = mobileFiles("rx_bytes");
		private final static File SYS_CLASS_NET_DIR = new File("/sys/class/net");

		/**
		* Get total number of tx packets sent through rmnet0 or ppp0
		*
		* @return number of Tx packets through rmnet0 or ppp0
		*/
		public static long getMobileTxPkts() {
		return getMobileStat(MOBILE_TX_PACKETS);
		}

		/**
		* Get total number of rx packets received through rmnet0 or ppp0
		*
		* @return number of Rx packets through rmnet0 or ppp0
		*/
		public static long getMobileRxPkts() {
		return getMobileStat(MOBILE_RX_PACKETS);
		}

		/**
		* Get total number of tx bytes received through rmnet0 or ppp0
		*
		* @return number of Tx bytes through rmnet0 or ppp0
		*/
		public static long getMobileTxBytes() {
		return getMobileStat(MOBILE_TX_BYTES);
		}

		/**
		* Get total number of rx bytes received through rmnet0 or ppp0
		*
		* @return number of Rx bytes through rmnet0 or ppp0
		*/
		public static long getMobileRxBytes() {
		return getMobileStat(MOBILE_RX_BYTES);
		}

		/**
		* Get the total number of packets sent through all network interfaces.
		*
		* @return the number of packets sent through all network interfaces
		*/
		public static long getTotalTxPkts() {
		return getTotalStat("tx_packets");
		}

		/**
		* Get the total number of packets received through all network interfaces.
		*
		* @return the number of packets received through all network interfaces
		*/
		public static long getTotalRxPkts() {
		return getTotalStat("rx_packets");
		}

		/**
		* Get the total number of bytes sent through all network interfaces.
		*
		* @return the number of bytes sent through all network interfaces
		*/
		public static long getTotalTxBytes() {
		return getTotalStat("tx_bytes");
		}

		/**
		* Get the total number of bytes received through all network interfaces.
		*
		* @return the number of bytes received through all network interfaces
		*/
		public static long getTotalRxBytes() {
		return getTotalStat("rx_bytes");
		}

		/**
		* Gets network bytes sent for this UID.
		* The statistics are across all interfaces.
		* The statistics come from /proc/uid_stat.
		*
		* {@see android.os.Process#myUid()}.
		*
		* @param uid
		* @return byte count
		*/
		public static long getUidTxBytes(int uid) {
		return getNumberFromFilePath("/proc/uid_stat/" + uid + "/tcp_snd");
		}

		/**
		* Gets network bytes received for this UID.
		* The statistics are across all interfaces.
		* The statistics come from /proc/uid_stat.
		*
		* {@see android.os.Process#myUid()}.
		*
		* @param uid
		* @return byte count
		*/
		public static long getUidRxBytes(int uid) {
		return getNumberFromFilePath("/proc/uid_stat/" + uid + "/tcp_rcv");
		}

		/**
		* Returns the array of two possible File locations for a given
		* statistic.
		*/
		private static File[] mobileFiles(String whatStat) {
		// Note that we stat them at runtime to see which is
		// available, rather than here, to guard against the files
		// coming & going later as modules shut down (e.g. airplane
		// mode) and whatnot. The runtime stat() isn't expensive compared
		// to the previous charset conversion that happened before we
		// were reusing File instances.
		File[] files = new File[2];
		files[0] = new File("/sys/class/net/rmnet0/statistics/" + whatStat);
		files[1] = new File("/sys/class/net/ppp0/statistics/" + whatStat);
		return files;
		}

		private static long getTotalStat(String whatStat) {
		File netdir = new File("/sys/class/net");

		File[] nets = SYS_CLASS_NET_DIR.listFiles();
		if (nets == null) {
		return 0;
		}
		long total = 0;
		StringBuffer strbuf = new StringBuffer();
		for (File net : nets) {
		strbuf.append(net.getPath()).append(File.separator).append("statistics")
		.append(File.separator).append(whatStat);
		total += getNumberFromFilePath(strbuf.toString());
		strbuf.setLength(0);
		}
		return total;
		}

		private static long getMobileStat(File[] files) {
		for (int i = 0; i < files.length; i++) {
		File file = files[i];
		if (!file.exists()) {
		continue;
		}
		try {
		RandomAccessFile raf = new RandomAccessFile(file, "r");
		return getNumberFromFile(raf, file.getAbsolutePath());
		} catch (IOException e) {
		Log.w(TAG,
		"Exception opening TCP statistics file " + file.getAbsolutePath(),
		e);
		}
		}
		return 0L;
		}

		// File will have format <number><newline>
		private static long getNumberFromFilePath(String filename) {
		RandomAccessFile raf = getFile(filename);
		if (raf == null) {
		return 0L;
		}
		return getNumberFromFile(raf, filename);
		}

		// Private buffer for getNumberFromFile. Safe for re-use because
		// getNumberFromFile is synchronized.
		private final static byte[] buf = new byte[16];

		private static synchronized long getNumberFromFile(RandomAccessFile raf, String filename) {
		try {
		raf.read(buf);
		raf.close();
		} catch (IOException e) {
		Log.w(TAG, "Exception getting TCP bytes from " + filename, e);
		return 0L;
		} finally {
		if (raf != null) {
		try {
		raf.close();
		} catch (IOException e) {
		Log.w(TAG, "Exception closing " + filename, e);
		}
		}
		}

		long num = 0L;
		for (int i = 0; i < buf.length; i++) {
		if (buf[i] < '0' \|\| buf[i] > '9') {
		break;
		}
		num *= 10;
		num += buf[i] - '0';
		}
		return num;
		}

		private static RandomAccessFile getFile(String filename) {
		File f = new File(filename);
		if (!f.canRead()) {
		return null;
		}

		try {
		return new RandomAccessFile(f, "r");
		} catch (IOException e) {
		Log.w(TAG, "Exception opening TCP statistics file " + filename, e);
		return null;
		}
		}
		}

core/java/com/android/internal/os/BatteryStatsImpl.java

+17 −17

Original line number	Diff line number	Diff line
		@@ -17,8 +17,8 @@
		package com.android.internal.os;

		import android.bluetooth.BluetoothHeadset;
		import android.net.TrafficStats;
		import android.os.BatteryStats;
		import android.os.NetStat;
		import android.os.Parcel;
		import android.os.ParcelFormatException;
		import android.os.Parcelable;
		@@ -1022,8 +1022,8 @@ public final class BatteryStatsImpl extends BatteryStats {
		public void doUnplug(long batteryUptime, long batteryRealtime) {
		for (int iu = mUidStats.size() - 1; iu >= 0; iu--) {
		Uid u = mUidStats.valueAt(iu);
		u.mStartedTcpBytesReceived = NetStat.getUidRxBytes(u.mUid);
		u.mStartedTcpBytesSent = NetStat.getUidTxBytes(u.mUid);
		u.mStartedTcpBytesReceived = TrafficStats.getUidRxBytes(u.mUid);
		u.mStartedTcpBytesSent = TrafficStats.getUidTxBytes(u.mUid);
		u.mTcpBytesReceivedAtLastUnplug = u.mCurrentTcpBytesReceived;
		u.mTcpBytesSentAtLastUnplug = u.mCurrentTcpBytesSent;
		}
		@@ -1031,10 +1031,10 @@ public final class BatteryStatsImpl extends BatteryStats {
		mUnpluggables.get(i).unplug(batteryUptime, batteryRealtime);
		}
		// Track total mobile data
		doDataUnplug(mMobileDataRx, NetStat.getMobileRxBytes());
		doDataUnplug(mMobileDataTx, NetStat.getMobileTxBytes());
		doDataUnplug(mTotalDataRx, NetStat.getTotalRxBytes());
		doDataUnplug(mTotalDataTx, NetStat.getTotalTxBytes());
		doDataUnplug(mMobileDataRx, TrafficStats.getMobileRxBytes());
		doDataUnplug(mMobileDataTx, TrafficStats.getMobileTxBytes());
		doDataUnplug(mTotalDataRx, TrafficStats.getTotalRxBytes());
		doDataUnplug(mTotalDataTx, TrafficStats.getTotalTxBytes());
		// Track radio awake time
		mRadioDataStart = getCurrentRadioDataUptime();
		mRadioDataUptime = 0;
		@@ -1058,10 +1058,10 @@ public final class BatteryStatsImpl extends BatteryStats {
		for (int i = mUnpluggables.size() - 1; i >= 0; i--) {
		mUnpluggables.get(i).plug(batteryUptime, batteryRealtime);
		}
		doDataPlug(mMobileDataRx, NetStat.getMobileRxBytes());
		doDataPlug(mMobileDataTx, NetStat.getMobileTxBytes());
		doDataPlug(mTotalDataRx, NetStat.getTotalRxBytes());
		doDataPlug(mTotalDataTx, NetStat.getTotalTxBytes());
		doDataPlug(mMobileDataRx, TrafficStats.getMobileRxBytes());
		doDataPlug(mMobileDataTx, TrafficStats.getMobileTxBytes());
		doDataPlug(mTotalDataRx, TrafficStats.getTotalRxBytes());
		doDataPlug(mTotalDataTx, TrafficStats.getTotalTxBytes());
		// Track radio awake time
		mRadioDataUptime = getRadioDataUptime();
		mRadioDataStart = -1;
		@@ -1519,7 +1519,7 @@ public final class BatteryStatsImpl extends BatteryStats {

		public long computeCurrentTcpBytesReceived() {
		return mCurrentTcpBytesReceived + (mStartedTcpBytesReceived >= 0
		? (NetStat.getUidRxBytes(mUid) - mStartedTcpBytesReceived) : 0);
		? (TrafficStats.getUidRxBytes(mUid) - mStartedTcpBytesReceived) : 0);
		}

		@Override
		@@ -1696,7 +1696,7 @@ public final class BatteryStatsImpl extends BatteryStats {

		public long computeCurrentTcpBytesSent() {
		return mCurrentTcpBytesSent + (mStartedTcpBytesSent >= 0
		? (NetStat.getUidTxBytes(mUid) - mStartedTcpBytesSent) : 0);
		? (TrafficStats.getUidTxBytes(mUid) - mStartedTcpBytesSent) : 0);
		}

		void writeToParcelLocked(Parcel out, long batteryRealtime) {
		@@ -2919,22 +2919,22 @@ public final class BatteryStatsImpl extends BatteryStats {

		/** Only STATS_UNPLUGGED works properly */
		public long getMobileTcpBytesSent(int which) {
		return getTcpBytes(NetStat.getMobileTxBytes(), mMobileDataTx, which);
		return getTcpBytes(TrafficStats.getMobileTxBytes(), mMobileDataTx, which);
		}

		/** Only STATS_UNPLUGGED works properly */
		public long getMobileTcpBytesReceived(int which) {
		return getTcpBytes(NetStat.getMobileRxBytes(), mMobileDataRx, which);
		return getTcpBytes(TrafficStats.getMobileRxBytes(), mMobileDataRx, which);
		}

		/** Only STATS_UNPLUGGED works properly */
		public long getTotalTcpBytesSent(int which) {
		return getTcpBytes(NetStat.getTotalTxBytes(), mTotalDataTx, which);
		return getTcpBytes(TrafficStats.getTotalTxBytes(), mTotalDataTx, which);
		}

		/** Only STATS_UNPLUGGED works properly */
		public long getTotalTcpBytesReceived(int which) {
		return getTcpBytes(NetStat.getTotalRxBytes(), mTotalDataRx, which);
		return getTcpBytes(TrafficStats.getTotalRxBytes(), mTotalDataRx, which);
		}

		@Override

core/java/com/google/android/net/GoogleHttpClient.java

+4 −4

Original line number	Diff line number	Diff line
		@@ -19,13 +19,14 @@ package com.google.android.net;
		import android.content.ContentResolver;
		import android.content.ContentValues;
		import android.content.Context;
		import android.net.TrafficStats;
		import android.net.http.AndroidHttpClient;
		import android.os.Build;
		import android.os.NetStat;
		import android.os.SystemClock;
		import android.provider.Checkin;
		import android.util.Config;
		import android.util.Log;
		import org.apache.harmony.xnet.provider.jsse.SSLClientSessionCache;
		import org.apache.http.HttpEntity;
		import org.apache.http.HttpEntityEnclosingRequest;
		import org.apache.http.HttpHost;
		@@ -45,7 +46,6 @@ import org.apache.http.impl.client.EntityEnclosingRequestWrapper;
		import org.apache.http.impl.client.RequestWrapper;
		import org.apache.http.params.HttpParams;
		import org.apache.http.protocol.HttpContext;
		import org.apache.harmony.xnet.provider.jsse.SSLClientSessionCache;

		import java.io.IOException;
		import java.net.InetAddress;
		@@ -205,8 +205,8 @@ public class GoogleHttpClient implements HttpClient {
		// to follow redirects, count each redirect as an additional round trip.

		int uid = android.os.Process.myUid();
		long startTx = NetStat.getUidTxBytes(uid);
		long startRx = NetStat.getUidRxBytes(uid);
		long startTx = TrafficStats.getUidTxBytes(uid);
		long startRx = TrafficStats.getUidRxBytes(uid);

		response = mClient.execute(request, context);
		HttpEntity origEntity = response == null ? null : response.getEntity();