如何在Android上查找每个应用程序的数据使用情况？

我试图了解每个应用程序在Android上的数据使用情况。差不多

我看了一下堆栈溢出问题

但这没有多大帮助

---

ActivityManager ActivityManager=（ActivityManager）this.getSystemService（ACTIVITY_服务）；
ActivityManager.MemoryInfo mInfo=新建ActivityManager.MemoryInfo（）；
activityManager.getMemoryInfo（mInfo）；
List listOfRunningProcess=activityManager.GetRunningAppProcess（）；
Log.d（标记“XXSize:+listOfRunningProcess.size（））；
对于（RunningAppProcessInfo RunningAppProcessInfo:listOfRunningProcess）{
如果（运行AppProcessInfo.uid>1026）
{
Log.d（标记“ANS”+runningAppProcessInfo.processName+
“Id:”+runningAppProcessInfo.pid+
“UID:”+runningAppProcessInfo.UID）；
}
}

---

我尝试了上面的代码。然而，所有的都是数字，不像你上面提到的那样。这样可以吗？

以下链接将帮助您了解如何以编程方式确定每个应用程序的数据使用情况

---

您需要实现代码以使用API并跟踪每个UID（应用程序）发送/接收的字节数。

按程序设计：

您可以为

操作(MANAGE)网络(USAGE)

操作(在Android 4.0中引入)声明意图过滤器以指示您的应用程序定义了一个提供控制数据使用选项的活动<代码>操作\管理\网络\使用情况显示用于管理特定应用程序的网络数据使用情况的设置。当您的应用程序具有允许用户控制网络使用的设置活动时，您应该为该活动声明此意向筛选器。 有关管理数据使用的更多信息，请查看此链接

---

ACTION\u MANAGE\u NETWORK\u USAGE的正确定义是您可以看到。
在创建一个新的类包Information Total后使用此方法

public void getPakagesInfoUsingHashMap() {
    final PackageManager pm = getPackageManager();
    // get a list of installed apps.
    List<ApplicationInfo> packages = pm.getInstalledApplications(0);

    // loop through the list of installed packages and see if the selected
    // app is in the list
    for (ApplicationInfo packageInfo : packages) {
        // get the UID for the selected app
        UID = packageInfo.uid;
        String package_name = packageInfo.packageName;
        ApplicationInfo app = null;
        try {
            app = pm.getApplicationInfo(package_name, 0);
        } catch (NameNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        String name = (String) pm.getApplicationLabel(app);
        Drawable icon = pm.getApplicationIcon(app);
        // internet usage for particular app(sent and received)
        double received = (double) TrafficStats.getUidRxBytes(UID)

                / (1024 * 1024);
        double send = (double) TrafficStats.getUidTxBytes(UID)
                / (1024 * 1024);
        double total = received + send;

        if(total>0)
        {
            PackageInformationTotal pi=new PackageInformationTotal();
            pi.name=name;
            pi.packageName=package_name;
            pi.icon=icon;               
            pi.totalMB=String.format( "%.2f", total )+" MB";
            pi.individual_mb=String.format( "%.2f", total );
            totalData+=Double.parseDouble(String.format( "%.2f", total ));
            dataHash.add(pi);
        Log.e(name,String.format( "%.2f", total )+" MB");
        }

    }
    Editor edit=shared.edit();
    edit.putString("Total",String.format( "%.2f", totalData));
    edit.commit();
}

public void getPakagesInFoundingHashMap（）{
最终PackageManager pm=getPackageManager（）；
//获取已安装应用程序的列表。
列表包=pm.getInstalledApplication（0）；
//循环浏览已安装软件包的列表，查看是否选择了
//应用程序在列表中
对于（ApplicationInfo packageInfo:packages）{
//获取所选应用程序的UID
UID=packageInfo.UID；
字符串package_name=packageInfo.packageName；
ApplicationInfo-app=null；
试一试{
app=pm.getApplicationInfo（包名称，0）；
}catch（nameNotFounde异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
字符串名称=（字符串）pm.getApplicationLabel（应用程序）；
可绘制图标=pm.getApplicationOn（应用程序）；
//特定应用的互联网使用情况（发送和接收）
double received=（double）TrafficStats.getUidRxBytes（UID）
/ (1024 * 1024);
double send=（double）TrafficStats.getUidTxBytes（UID）
/ (1024 * 1024);
双倍合计=接收+发送；
如果（总数>0）
{
PackageInformationTotal pi=新的PackageInformationTotal（）；
pi.name=name；
pi.packageName=包名称；
pi.icon=icon；
pi.totalMB=String.format（“%.2f”，总计）+“MB”；
pi.individual_mb=String.format（“%.2f”，总计）；
totalData+=Double.parseDouble（String.format（“%.2f”，total））；
dataHash.add（pi）；
Log.e（名称、字符串格式（“%.2f”，总计）+“MB”）；
}
}
Editor edit=shared.edit（）；
edit.putString（“Total”，String.format（“%.2f”，totalData））；
edit.commit（）；
}

之后，您可以用MB跟踪所有进程的使用情况。
经过长期的努力，我能够找到通过android中每个已安装应用程序的任何接口获取数据的解决方案
装置

由于Android提供TrafficStats API，但这些API为每个应用程序uid提供了自设备启动以来的复杂数据统计，甚至
API不支持通过特定应用程序的任何接口获取数据。
即使我们依赖Traffiuccates API，我们也会为每个应用程序获得新的数据统计

所以我想使用隐藏的API来使用这个

这里我要提到的是通过Android中的任何接口获取每个应用程序的数据统计信息的步骤

建立“INetworkStatsSession”会话

#导入android.net.INetworkStatsSession

INetworkStatsSession mStatsSession=mStatsService.openSession（）

根据要测量的间隔创建网络模板

#import static android.net.NetworkTemplate.buildTemplateEthernet;
#import static android.net.NetworkTemplate.buildTemplateMobile3gLower;
#import static android.net.NetworkTemplate.buildTemplateMobile4g;
#import static android.net.NetworkTemplate.buildTemplateMobileAll;
#import static android.net.NetworkTemplate.buildTemplateWifiWildcard;

#import android.net.NetworkTemplate;

private NetworkTemplate mTemplate;

mTemplate = buildTemplateMobileAll(getActiveSubscriberId(this
                .getApplicationContext()));


GetActive SubcriberID：

private static String getActiveSubscriberId(Context context) {
    final TelephonyManager tele = TelephonyManager.from(context);
    final String actualSubscriberId = tele.getSubscriberId();
    return SystemProperties.get(TEST_SUBSCRIBER_PROP, actualSubscriberId);
}


通过应用程序UID收集各个应用程序的网络历史记录

 private NetworkStatsHistory collectHistoryForUid(NetworkTemplate template,
        int uid, int set) throws RemoteException {
    final NetworkStatsHistory history = mStatsSession.getHistoryForUid(
            template, uid, set, TAG_NONE, FIELD_RX_BYTES | FIELD_TX_BYTES);
    return history;

}


获取总消耗数据：

public void showConsuption(int UID){
    NetworkStatsHistory history = collectHistoryForUid(mTemplate, UID,
            SET_DEFAULT);

    Log.i(DEBUG_TAG, "load:::::SET_DEFAULT:.getTotalBytes:"+ Formatter.formatFileSize(context, history.getTotalBytes()));

    history = collectHistoryForUid(mTemplate, 10093,
            SET_FOREGROUND);
    Log.i(DEBUG_TAG, "load::::SET_FOREGROUND::.getTotalBytes:"+ Formatter.formatFileSize(context, history.getTotalBytes()));

    history = collectHistoryForUid(mTemplate, 10093,
            SET_ALL);
    Log.i(DEBUG_TAG, "load::::SET_ALL::.getTotalBytes:"+ Formatter.formatFileSize(context, history.getTotalBytes()));

}


此代码段也适用于那些在设备中实际运行的应用程序

final PackageManager pm = getPackageManager();

ActivityManager activityManager = (ActivityManager) this.getSystemService(Context.ACTIVITY_SERVICE);
List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
//final List<ActivityManager.RunningTaskInfo> recentTasks = activityManager.getRunningTasks(Integer.MAX_VALUE);
for (int i = 0; i < appProcesses.size(); i++) {
    Log.d("Executed app", "Application executed : " + appProcesses.get(i).processName + "\t\t ID: " + appProcesses.get(i).pid + "");
    //  String packageName = activityManager.getRunningTasks(1).get(0).topActivity.getPackageName();
    //String packageName = appProcesses.get(i)..getPackageName();
    ApplicationInfo app = null;
    try {
        app = pm.getApplicationInfo(appProcesses.get(i).processName, 0);
        if ((app.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) == 1) {
            //it's a system app, not interested
        } else if ((app.flags & ApplicationInfo.FLAG_SYSTEM) == 1) {
            //Discard this one
            //in this case, it should be a user-installed app
        } else {
            // tx = TrafficStats.getUidTxBytes(app.uid);
            //rx = TrafficStats.getUidRxBytes(app.uid);
            long delta_rx = TrafficStats.getUidRxBytes(app.uid) - rx;

            long delta_tx = TrafficStats.getUidTxBytes(app.uid) - tx;
        }
    }

final PackageManager pm=getPackageManager（）；
ActivityManager ActivityManager=（ActivityManager）this.getSystemService（Context.ACTIVITY_服务）；
List appProcesses=activityManager.getRunningAppProcesses（）；
//最终列表recentTasks=activityManager.getRunningTasks（Integer.MAX_值）；
对于（int i=0；ifinal PackageManager pm = getPackageManager();

ActivityManager activityManager = (ActivityManager) this.getSystemService(Context.ACTIVITY_SERVICE);
List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
//final List<ActivityManager.RunningTaskInfo> recentTasks = activityManager.getRunningTasks(Integer.MAX_VALUE);
for (int i = 0; i < appProcesses.size(); i++) {
    Log.d("Executed app", "Application executed : " + appProcesses.get(i).processName + "\t\t ID: " + appProcesses.get(i).pid + "");
    //  String packageName = activityManager.getRunningTasks(1).get(0).topActivity.getPackageName();
    //String packageName = appProcesses.get(i)..getPackageName();
    ApplicationInfo app = null;
    try {
        app = pm.getApplicationInfo(appProcesses.get(i).processName, 0);
        if ((app.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) == 1) {
            //it's a system app, not interested
        } else if ((app.flags & ApplicationInfo.FLAG_SYSTEM) == 1) {
            //Discard this one
            //in this case, it should be a user-installed app
        } else {
            // tx = TrafficStats.getUidTxBytes(app.uid);
            //rx = TrafficStats.getUidRxBytes(app.uid);
            long delta_rx = TrafficStats.getUidRxBytes(app.uid) - rx;

            long delta_tx = TrafficStats.getUidTxBytes(app.uid) - tx;
        }
    }

 public class Main extends Activity {

    private Handler mHandler = new Handler();
    private long mStartRX = 0;
    private long mStartTX = 0;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        mStartRX = TrafficStats.getTotalRxBytes();
        mStartTX = TrafficStats.getTotalTxBytes();
        if (mStartRX == TrafficStats.UNSUPPORTED || mStartTX == TrafficStats.UNSUPPORTED) {
            AlertDialog.Builder alert = new AlertDialog.Builder(this);
            alert.setTitle("Uh Oh!");
            alert.setMessage("Your device does not support traffic stat monitoring.");
            alert.show();
        } else {
            mHandler.postDelayed(mRunnable, 1000);
        }
    }

    private final Runnable mRunnable = new Runnable() {
        public void run() {
            TextView RX = (TextView)findViewById(R.id.RX);
            TextView TX = (TextView)findViewById(R.id.TX);
            long rxBytes = TrafficStats.getTotalRxBytes()- mStartRX;
            RX.setText(Long.toString(rxBytes));
            long txBytes = TrafficStats.getTotalTxBytes()- mStartTX;
            TX.setText(Long.toString(txBytes));
            mHandler.postDelayed(mRunnable, 1000);
        }
     };
}

PackageManager packageManager = context.getPackageManager();

ApplicationInfo info = packageManager.getApplicationInfo("com.example.app", 0); 

int packageUid = info.uid;

NetworkStats.Bucket bucket = networkStatsManager.queryDetailsForUid(ConnectivityManager.TYPE_MOBILE, getSubscriberId(context, ConnectivityManager.TYPE_MOBILE), 0, System.currentTimeMillis(),packageUid);
            
            
    
long rxBytes = 0L;
           
long txBytes = 0L;
            
NetworkStats.Bucket bucket = new NetworkStats.Bucket();
           
while (networkStats.hasNextBucket()) {
            
     networkStats.getNextBucket(bucket);
     rxBytes += bucket.getRxBytes();
     txBytes += bucket.getTxBytes(); 
}
networkStats.close();