usar - ¿Cómo puedo encontrar el uso de datos por aplicación en Android?

reiniciar uso de datos android

Question

Estoy tratando de averiguar el uso de datos en Android por aplicación. Algo así como las aplicaciones de uso de datos de Android y los widgets de monitores de cuota / tapa: ¡nunca más se le cobrará por los datos ni se le aplicará un tope de nuevo! .

Miré la pregunta de Stack Overflow Cómo detectar el uso de datos en el entorno de Android .

Pero no ha sido de mucha ayuda.

ActivityManager activityManager = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
ActivityManager.MemoryInfo mInfo = new ActivityManager.MemoryInfo();
activityManager.getMemoryInfo( mInfo );
List<RunningAppProcessInfo> listOfRunningProcess = activityManager.getRunningAppProcesses();
Log.d(TAG, "XXSize: " + listOfRunningProcess.size());

for (RunningAppProcessInfo runningAppProcessInfo : listOfRunningProcess) {

    if (runningAppProcessInfo.uid > 1026)
    {
        Log.d(TAG, "ANS " + runningAppProcessInfo.processName +
                   " Id :" + runningAppProcessInfo.pid +
                   " UID: " + runningAppProcessInfo.uid);
    }
}

Probé el código anterior como lo sugirió Akos Cz . Sin embargo, todos los UIDs son números, a diferencia de app_79 como mencionaste anteriormente. ¿Está todo bien?

Answer 1

Ahora hay una opción de usar la herramienta DDMS Network Traffic

http://developer.android.com/training/efficient-downloads/efficient-network-access.html#DDMSNetworkTraffic

Answer 2

Después de una larga lucha, puedo encontrar la Solución para obtener datos a través de cualquier interfaz para cada Aplicación instalada en un dispositivo Android.

Como Android proporciona TrafficStats Apis, estas API proporcionan estadísticas de datos completas para cada aplicación, ya que el inicio del dispositivo y las API pares no son compatibles para obtener los datos a través de cualquier interfaz para una aplicación en particular. Incluso si confiamos en TraffiucStates APIS, obtenemos nuevos datos estadísticos para cada aplicación.

Así que pensé usar las API ocultas para usar esto ...

Aquí menciono los pasos para obtener estadísticas de datos para cada aplicación sobre cualquier interfaz en Android ...

1. Estabalish una sesión "INetworkStatsSession"

   #import android.net.INetworkStatsSession;

INetworkStatsSession mStatsSession = mStatsService.openSession ();

2. Crea una red Templeate según interafce que quieras medir.

   #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()));

3. 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);
   }

4. Reúna la red HIStory de la aplicación respectiva pasando los UID de la aplicación ...

    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;
   
   }

5. Obtenga los datos de Consumo total:

   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()));
   
   }

Answer 3

Este fragmento también funciona para aquellos que realmente ejecutan aplicaciones en su dispositivo

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;
        }
    }

Answer 4

Los siguientes enlaces le ayudarán a descubrir cómo determinar programáticamente el uso de datos por aplicación.

• cw-andtuning/TrafficMonitor (GitHub)

• Crea un monitor de red usando la clase TrafficStats de Android

• Estadísticas de tráfico de Android en el interior

Tendrá que implementar su código para usar la API de TraficStats y hacer un seguimiento del número de bytes enviados / recibidos por UID (aplicación).

Answer 5

Use este método después de crear una nueva clase PackageInformationTotal.

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();
}

Después de eso, puede seguir todos los usos del proceso en MB.

Answer 6

Proramáticamente

Puede declarar el filtro de intención para la acción ACTION_MANAGE_NETWORK_USAGE (introducido en Android 4.0) para indicar que su aplicación define una actividad que ofrece opciones para controlar el uso de datos. ACTION_MANAGE_NETWORK_USAGE muestra configuraciones para administrar el uso de datos de red de una aplicación específica. Cuando su aplicación tiene una actividad de configuración que permite a los usuarios controlar el uso de la red, debe declarar este filtro de intención para esa actividad. Consulte esto para obtener más información sobre cómo administrar el uso de la administración de uso de datos por aplicación .

La definición adecuada de ACTION_MANAGE_NETWORK_USAGE es la que puede ver here .

Answer 7

 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);
        }
     };
}

También puede consultar cw-andtuning/TrafficMonitor