Merge "idle test app for bandwidth usage."

#

# Copyright (C) 2011 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.

#

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

# We only want this apk build for tests.

LOCAL_MODULE_TAGS := tests

LOCAL_PACKAGE_NAME := DataIdleTest

LOCAL_JAVA_LIBRARIES := android.test.runner

LOCAL_SRC_FILES := $(call all-java-files-under, src)

# We need to sign it to get access to the network usage history.

LOCAL_CERTIFICATE := platform

include $(BUILD_PACKAGE)

<?xml version="1.0" encoding="utf-8"?>

<!-- Copyright (C) 2011 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.

-->

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

  package="com.android.tests.dataidle"

  android:sharedUserId="android.uid.system">

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

    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

    <uses-permission android:name="android.permission.READ_NETWORK_USAGE_HISTORY" />

    <application >

        <uses-library android:name="android.test.runner" />

    </application>

    <instrumentation

        android:name="android.test.InstrumentationTestRunner"

        android:targetPackage="com.android.tests.dataidle"

        android:label="Idle Bandwidth Tests" />

</manifest>

/*

 * Copyright (C) 2011 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 com.android.tests.dataidle;

import android.content.Context;

import android.net.INetworkStatsService;

import android.net.NetworkStats.Entry;

import android.net.NetworkTemplate;

import android.net.NetworkStats;

import android.os.Bundle;

import android.os.RemoteException;

import android.os.ServiceManager;

import android.telephony.TelephonyManager;

import android.test.InstrumentationTestCase;

import android.test.InstrumentationTestRunner;

import android.util.Log;

/**

 * A test that dumps data usage to instrumentation out, used for measuring data usage for idle

 * devices.

 */

public class DataIdleTest extends InstrumentationTestCase {

    private TelephonyManager mTelephonyManager;

    private INetworkStatsService mStatsService;

    private static final String LOG_TAG = "DataIdleTest";

    private final static int INSTRUMENTATION_IN_PROGRESS = 2;

    protected void setUp() throws Exception {

        super.setUp();

        Context c = getInstrumentation().getTargetContext();

        mStatsService = INetworkStatsService.Stub.asInterface(

                ServiceManager.getService(Context.NETWORK_STATS_SERVICE));

        mTelephonyManager = (TelephonyManager) c.getSystemService(Context.TELEPHONY_SERVICE);

    }

    /**

     * Test that dumps all the data usage metrics for wifi to instrumentation out.

     */

    public void testWifiIdle() {

        NetworkTemplate template = NetworkTemplate.buildTemplateWifi();

        fetchStats(template);

    }

    /**

     * Test that dumps all the data usage metrics for all mobile to instrumentation out.

     */

    public void testMobile() {

        String subscriberId = mTelephonyManager.getSubscriberId();

        NetworkTemplate template = NetworkTemplate.buildTemplateMobileAll(subscriberId);

        fetchStats(template);

    }

    /**

     * Helper method that fetches all the network stats available and reports it

     * to instrumentation out.

     * @param template {link {@link NetworkTemplate} to match.

     */

    private void fetchStats(NetworkTemplate template) {

        try {

            NetworkStats stats = mStatsService.getSummaryForAllUid(template, Long.MIN_VALUE,

                    Long.MAX_VALUE, false);

            reportStats(stats);

        } catch (RemoteException e) {

            Log.w(LOG_TAG, "Failed to fetch network stats for wifi.");

        }

    }

    /**

     * Print network data usage stats to instrumentation out

     * @param stats {@link NetworkorStats} to print

     */

    void reportStats(NetworkStats stats) {

        for (int i = 0; i < stats.size(); ++i) {

            Entry  statsEntry = stats.getValues(i, null);

            Bundle result = new Bundle();

            result.putInt("uid", statsEntry.uid);

            result.putInt("tag", statsEntry.tag);

            result.putInt("set", statsEntry.set);

            result.putString("iface", statsEntry.iface);

            result.putLong("rxBytes", statsEntry.rxBytes);

            result.putLong("txBytes", statsEntry.txBytes);

            getInstrumentation().sendStatus(INSTRUMENTATION_IN_PROGRESS, result);

        }

    }

}