acts_tests/tests/google/net/DataUsageTest.py

#
#   Copyright 2018 - 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.

import threading
import time

from acts import asserts
from acts import base_test
from acts import utils
from acts.controllers import adb
from acts.controllers.adb_lib.error import AdbError
from acts.controllers.ap_lib import hostapd_constants
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.net import connectivity_const as cconst
from acts_contrib.test_utils.net import connectivity_test_utils as cutils
from acts_contrib.test_utils.net import net_test_utils as nutils
from acts_contrib.test_utils.net.net_test_utils import start_tcpdump
from acts_contrib.test_utils.net.net_test_utils import stop_tcpdump
from acts_contrib.test_utils.tel import tel_test_utils as ttutils
from acts_contrib.test_utils.tel.tel_test_utils import get_operator_name
from acts_contrib.test_utils.tel.tel_test_utils import http_file_download_by_chrome
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
import queue
from queue import Empty


conn_test_class = "com.android.tests.connectivity.uid.ConnectivityTestActivity"
android_os_class = "com.quicinc.cne.CNEService.CNEServiceApp"
instr_cmd = ("am instrument -w -e command grant-all "
             "com.android.permissionutils/.PermissionInstrumentation")

HOUR_IN_MILLIS = 1000 * 60 * 60
BYTE_TO_MB_ANDROID = 1000.0 * 1000.0
BYTE_TO_MB = 1024.0 * 1024.0
DOWNLOAD_PATH = "/sdcard/download/"
DATA_USG_ERR = 2.2
DATA_ERR = 0.2
TIMEOUT = 2 * 60
INC_DATA = 10
AP_PASSPHRASE_LENGTH_2G = hostapd_constants.AP_PASSPHRASE_LENGTH_2G
AP_SSID_LENGTH_2G = hostapd_constants.AP_SSID_LENGTH_2G
RETRY_SLEEP = 3
WIFI_SLEEP = 180


class DataUsageTest(base_test.BaseTestClass):
    """Data usage tests.

    Requirements:
       Two Pixel devices - one device with TMO and other with VZW SIM
       WiFi network - Wifi network to test wifi data usage
    """

    def __init__(self, controllers):
        base_test.BaseTestClass.__init__(self, controllers)

    def setup_class(self):
        """Setup devices for tests and unpack params."""

        # unpack user params
        req_params = ("wifi_network",
                      "file_size",
                      "download_file_ipv4",
                      "download_file_ipv6",
                      "dbs_supported_models")
        self.unpack_userparams(req_params)
        self.file_path = DOWNLOAD_PATH + self.download_file_ipv4.split("/")[-1]
        self.file_size = float(self.file_size)

        for ad in self.android_devices:
            self.log.info("Operator on %s is %s" % \
                          (ad.serial, get_operator_name(self.log, ad)))
            ad.reboot()
            nutils.verify_lte_data_and_tethering_supported(ad)
            nutils.set_chrome_browser_permissions(ad)
            cutils.set_private_dns(ad, cconst.PRIVATE_DNS_MODE_OFF)
            try:
                ad.adb.shell(instr_cmd)
            except AdbError:
                self.log.warn("cmd %s failed on %s" % (instr_cmd, ad.serial))
        self.tcpdumps = []
        self.hs_enabled = []

    def setup_test(self):
        for ad in self.android_devices:
            self.tcpdumps.append(start_tcpdump(ad, self.test_name))
            ad.droid.wakeLockAcquireBright()
            ad.droid.wakeUpNow()

    def teardown_test(self):
        for ad in self.hs_enabled:
            try:
                wutils.stop_wifi_tethering(ad)
            except Exception as e:
              self.log.warn("Failed to stop wifi tethering: %s" % e)
        self.hs_enabled = []
        for i in range(len(self.android_devices)):
            ad = self.android_devices[i]
            stop_tcpdump(ad, self.tcpdumps[i], self.test_name)
            wutils.reset_wifi(ad)
            sub_id = str(ad.droid.telephonyGetSubscriberId())
            ad.droid.connectivityFactoryResetNetworkPolicies(sub_id)
            ad.droid.telephonyToggleDataConnection(True)
            ad.droid.wakeLockRelease()
            ad.droid.goToSleepNow()
        self.tcpdumps = []

    def teardown_class(self):
        for ad in self.android_devices:
            cutils.set_private_dns(ad, cconst.PRIVATE_DNS_MODE_OPPORTUNISTIC)

    def on_fail(self, test_name, begin_time):
        for ad in self.android_devices:
            ad.take_bug_report(test_name, begin_time)

    ### Helper functions

    def _download_data_through_app(self, ad, file_link):
        """Download data through app on DUT.

        Args:
            ad: DUT to download the file on
            file_link: http link of the file to download

        Returns:
            True if file download is successful, False if not
        """
        intent = ad.droid.createIntentForClassName(conn_test_class)
        json_obj = {"url": file_link}
        ad.droid.launchForResultWithIntent(intent, json_obj)
        download_status = False
        end_time = time.time() + TIMEOUT
        while time.time() < end_time:
            download_status = ttutils._check_file_existance(
                ad, self.file_path, self.file_size * BYTE_TO_MB)
            if download_status:
                self.log.info("Delete file: %s", self.file_path)
                ad.adb.shell("rm %s" % self.file_path, ignore_status=True)
                break
            time.sleep(RETRY_SLEEP*2)  # wait to check if download is complete
        return download_status

    def _get_total_data_usage_for_device(self, ad, conn_type):
        """Get total data usage in MB for device.

        Args:
            ad: android device object
            conn_type: MOBILE/WIFI data usage

        Returns:
            Data usage in MB
        """
        sub_id = str(ad.droid.telephonyGetSubscriberId())
        end_time = int(time.time() * 1000) + 2 * HOUR_IN_MILLIS
        data_usage = ad.droid.connectivityQuerySummaryForDevice(
            conn_type, sub_id, 0, end_time)
        data_usage /= BYTE_TO_MB_ANDROID
        self.log.info("Total data usage is: %s" % data_usage)
        return data_usage

    def _get_data_usage_for_uid_rx(self, ad, conn_type, uid):
        """Get data usage for UID in Rx Bytes.

        Args:
            ad: DUT to get data usage from
            conn_type: MOBILE/WIFI data usage
            uid: UID of the app

        Returns:
            Data usage in MB
        """
        subscriber_id = ad.droid.telephonyGetSubscriberId()
        end_time = int(time.time() * 1000) + 2 * HOUR_IN_MILLIS
        data_usage = ad.droid.connectivityQueryDetailsForUidRxBytes(
            conn_type, subscriber_id, 0, end_time, uid)
        return data_usage/BYTE_TO_MB_ANDROID

    def _get_data_usage_for_device_rx(self, ad, conn_type):
        """Get total data usage in rx bytes for device.

        Args:
            ad: DUT to get data usage from
            conn_type: MOBILE/WIFI data usage

        Returns:
            Data usage in MB
        """
        subscriber_id = ad.droid.telephonyGetSubscriberId()
        end_time = int(time.time() * 1000) + 2 * HOUR_IN_MILLIS
        data_usage = ad.droid.connectivityQuerySummaryForDeviceRxBytes(
            conn_type, subscriber_id, 0, end_time)
        return data_usage/BYTE_TO_MB_ANDROID

    def _get_data_usage(self, ad, conn_type):
        """Get data usage.

        Args:
            ad: DUT to get data usage from
            conn_type: MOBILE/WIFI data usage

        Returns:
            Tuple of Android Os app, Conn UID app, Total data usages
        """
        android_os_uid = ad.droid.getUidForPackage(android_os_class)
        conn_test_uid = ad.droid.getUidForPackage(conn_test_class)
        aos = self._get_data_usage_for_uid_rx(ad, conn_type, android_os_uid)
        app = self._get_data_usage_for_uid_rx(ad, conn_type, conn_test_uid)
        tot = self._get_data_usage_for_device_rx(ad, conn_type)
        self.log.info("Android Os data usage: %s" % aos)
        self.log.info("Conn UID Test data usage: %s" % app)
        self.log.info("Total data usage: %s" % tot)
        return (aos, app, tot)

    def _listen_for_network_callback(self, ad, event, q):
        """Verify network callback for data usage.

        Args:
            ad: DUT to get the network callback for
            event: Network callback event
            q: queue object

        Returns:
            True: if the expected network callback found, False if not
        """
        key = ad.droid.connectivityRegisterDefaultNetworkCallback()
        ad.droid.connectivityNetworkCallbackStartListeningForEvent(key, event)

        curr_time = time.time()
        status = False
        while time.time() < curr_time + TIMEOUT:
            try:
                nc_event = ad.ed.pop_event("NetworkCallback")
                self.log.info("Received: %s" %
                              nc_event["data"]["networkCallbackEvent"])
                if nc_event["data"]["networkCallbackEvent"] == event:
                    status = True
                    break
            except Empty:
                pass

        ad.droid.connectivityNetworkCallbackStopListeningForEvent(key, event)
        ad.droid.connectivityUnregisterNetworkCallback(key)
        q.put(status)

    def _test_data_usage_downlink(self,
                                  dut_a,
                                  dut_b,
                                  file_link,
                                  data_usage,
                                  tethering=False,
                                  connect_wifi=False,
                                  app_inc=True):
        """Verify data usage.

        Steps:
            1. Get the current data usage of ConnUIDTest and Android OS apps
            2. DUT is on LTE data (on wifi if connect_wifi is True)
            3. Download file of size xMB through ConnUIDTest app
            4. Verify that data usage of Android OS app did not change
            5. Verify that data usage of ConnUIDTest app increased by ~xMB
            6. Verify that data usage of device also increased by ~xMB

        Args:
            dut_a: DUT on which data usage need to be verified
            dut_b: DUT on which data is downloaded
            file_link: Link used to download data
            data_usage: specifies if MOBILE or WIFI data is calculated
            tethering: if True, enable hotspot on dut_a and connect dut_b to it
            connect_wifi: if True, connect dut_a to a wifi network
            app_inc: if True, verify app data usage on dut_a is increased
        """
        if connect_wifi:
            dut_a.droid.telephonyToggleDataConnection(False)
            wutils.start_wifi_connection_scan_and_ensure_network_found(
                dut_a, self.wifi_network["SSID"])
            wutils.wifi_connect(dut_a, self.wifi_network)
            # sleep for some time after connecting to wifi. some apps use wifi
            # data when connected initially. waiting after connecting to wifi
            # ensures correct wifi data usage calculation
            time.sleep(WIFI_SLEEP)

        if tethering:
            ssid = "hs_%s" % utils.rand_ascii_str(AP_SSID_LENGTH_2G)
            pwd = utils.rand_ascii_str(AP_PASSPHRASE_LENGTH_2G)
            network = {wutils.WifiEnums.SSID_KEY: ssid,
                       wutils.WifiEnums.PWD_KEY: pwd}
            dut_b.droid.telephonyToggleDataConnection(False)
            wutils.start_wifi_tethering(dut_a,
                                        network[wutils.WifiEnums.SSID_KEY],
                                        network[wutils.WifiEnums.PWD_KEY])
            self.hs_enabled.append(dut_a)
            wutils.start_wifi_connection_scan_and_ensure_network_found(
                dut_b, network[wutils.WifiEnums.SSID_KEY])
            wutils.wifi_connect(dut_b, network)
            # sleep for some time after connecting to wifi. though wifi hotspot
            # is metered, some apps would still use wifi data when connected
            # initially. this ensures correct wifi data usage calculation
            time.sleep(WIFI_SLEEP)

        # get pre data usage
        (aos_pre, app_pre, total_pre) = self._get_data_usage(dut_a, data_usage)

        # download file through app
        status = self._download_data_through_app(dut_b, file_link)
        asserts.assert_true(status, "Failed to download file: %s" % file_link)

        # get new data usage
        aos_exp = DATA_ERR
        app_exp = self.file_size + DATA_USG_ERR
        file_size = self.file_size
        if not app_inc:
            app_exp = DATA_ERR
            file_size = 0
        total_exp = self.file_size + DATA_USG_ERR

        # somtimes data usage is not increased immediately.
        # re-tries until the data usage is closed to expected value.
        curr_time = time.time()
        while time.time() < curr_time + TIMEOUT:
            (aos_pst, app_pst, total_pst) = self._get_data_usage(dut_a,
                                                                 data_usage)
            if total_pst - total_pre >= self.file_size and \
                app_pst - app_pre >= file_size:
                  # wait for some time to verify that data doesn't increase
                  time.sleep(RETRY_SLEEP*2)
                  break
            time.sleep(RETRY_SLEEP)  # wait before retry
        (aos_pst, app_pst, total_pst) = self._get_data_usage(dut_a, data_usage)

        # verify data usage
        aos_diff = aos_pst - aos_pre
        app_diff = app_pst - app_pre
        total_diff = total_pst - total_pre
        self.log.info("Usage of Android OS increased: %sMB, expected: %sMB" % \
                      (aos_diff, aos_exp))
        self.log.info("Usage of ConnUID app increased: %sMB, expected: %sMB" % \
                      (app_diff, app_exp))
        self.log.info("Usage on the device increased: %sMB, expected: %sMB" % \
                      (total_diff, total_exp))

        asserts.assert_true(
            (aos_diff < aos_exp) and (file_size <= app_diff < app_exp) and \
                (self.file_size <= total_diff < total_exp),
            "Incorrect data usage count")

    def _test_data_usage_limit_downlink(self,
                                        dut_a,
                                        dut_b,
                                        file_link,
                                        data_usage,
                                        tethering=False):
        """Verify data usage limit reached.

        Steps:
            1. Set the data usage limit to current data usage + 10MB
            2. If tested for tethered device, start wifi hotspot and
               connect DUT to it.
            3. If tested for tethered device, download 20MB data from
               tethered device else download on the same DUT
            4. Verify file download stops and data limit reached

        Args:
            dut_a: DUT on which data usage limit needs to be verified
            dut_b: DUT on which data needs to be downloaded
            file_link: specifies if the link is IPv4 or IPv6
            data_usage: specifies if MOBILE or WIFI data usage
            tethering: if wifi hotspot should be enabled on dut_a
        """
        sub_id = str(dut_a.droid.telephonyGetSubscriberId())

        # enable hotspot and connect dut_b to it.
        if tethering:
            ssid = "hs_%s" % utils.rand_ascii_str(AP_SSID_LENGTH_2G)
            pwd = utils.rand_ascii_str(AP_PASSPHRASE_LENGTH_2G)
            network = {wutils.WifiEnums.SSID_KEY: ssid,
                       wutils.WifiEnums.PWD_KEY: pwd}
            dut_b.droid.telephonyToggleDataConnection(False)
            wutils.start_wifi_tethering(dut_a,
                                        network[wutils.WifiEnums.SSID_KEY],
                                        network[wutils.WifiEnums.PWD_KEY])
            self.hs_enabled.append(dut_a)
            wutils.start_wifi_connection_scan_and_ensure_network_found(
                dut_b, network[wutils.WifiEnums.SSID_KEY])
            wutils.wifi_connect(dut_b, network)

        # get pre mobile data usage
        total_pre = self._get_total_data_usage_for_device(dut_a, data_usage)

        # set data usage limit to current usage limit + 10MB
        self.log.info("Set data usage limit to %sMB" % (total_pre + INC_DATA))
        dut_a.droid.connectivitySetDataUsageLimit(
            sub_id, int((total_pre + INC_DATA) * BYTE_TO_MB_ANDROID))

        # download file on dut_b and look for BlockedStatusChanged callback
        q = queue.Queue()
        t = threading.Thread(target=self._listen_for_network_callback,
                             args=(dut_a, "BlockedStatusChanged", q))
        t.daemon = True
        t.start()
        status = http_file_download_by_chrome(
            dut_b, file_link, self.file_size, True, TIMEOUT)
        t.join()
        cb_res = q.get()

        # verify file download fails and expected callback is recevied
        asserts.assert_true(cb_res,
                            "Failed to verify blocked status network callback")
        asserts.assert_true(not status,
                            "File download successful. Expected to fail")

    ### Test Cases

    @test_tracker_info(uuid="b2d9b36c-3a1c-47ca-a9c1-755450abb20c")
    def test_mobile_data_usage_downlink_ipv4_tmo(self):
        """Verify mobile data usage over IPv4 and TMO carrier."""
        self._test_data_usage_downlink(self.android_devices[0],
                                       self.android_devices[0],
                                       self.download_file_ipv4,
                                       cconst.TYPE_MOBILE)

    @test_tracker_info(uuid="fbbb58ed-d573-4bbd-bd5d-0bc540507896")
    def test_mobile_data_usage_downlink_ipv6_tmo(self):
        """Verify mobile data usage over IPv6 and TMO carrier."""
        self._test_data_usage_downlink(self.android_devices[0],
                                       self.android_devices[0],
                                       self.download_file_ipv6,
                                       cconst.TYPE_MOBILE)

    @test_tracker_info(uuid="6562d626-2271-4d93-96c0-f33138635330")
    def test_mobile_data_usage_downlink_ipv4_vzw(self):
        """Verify mobile data usage over IPv4 and VZW carrier."""
        self._test_data_usage_downlink(self.android_devices[1],
                                       self.android_devices[1],
                                       self.download_file_ipv4,
                                       cconst.TYPE_MOBILE)

    @test_tracker_info(uuid="2edf94cf-d937-459a-a7e4-2c679803c4d3")
    def test_mobile_data_usage_downlink_ipv6_vzw(self):
        """Verify mobile data usage over IPv6 and VZW carrier."""
        self._test_data_usage_downlink(self.android_devices[1],
                                       self.android_devices[1],
                                       self.download_file_ipv6,
                                       cconst.TYPE_MOBILE)

    @test_tracker_info(uuid="fe1390e5-635c-49a9-b050-032e66f52f40")
    def test_wifi_tethering_mobile_data_usage_downlink_ipv4_tmo(self):
        """Verify mobile data usage with tethered device over IPv4 and TMO."""
        self._test_data_usage_downlink(self.android_devices[0],
                                       self.android_devices[1],
                                       self.download_file_ipv4,
                                       cconst.TYPE_MOBILE,
                                       True,
                                       False,
                                       False)

    @test_tracker_info(uuid="d7fde6b2-6672-484a-a2fd-47858f5a163f")
    def test_wifi_tethering_mobile_data_usage_downlink_ipv6_tmo(self):
        """Verify mobile data usage with tethered device over IPv6 and TMO."""
        self._test_data_usage_downlink(self.android_devices[0],
                                       self.android_devices[1],
                                       self.download_file_ipv6,
                                       cconst.TYPE_MOBILE,
                                       True,
                                       False,
                                       False)

    @test_tracker_info(uuid="6285ef69-37a8-4069-8cb2-21dc266a57c3")
    def test_wifi_tethering_mobile_data_usage_downlink_ipv4_vzw(self):
        """Verify mobile data usage with tethered device over IPv4 and VZW."""
        self._test_data_usage_downlink(self.android_devices[1],
                                       self.android_devices[0],
                                       self.download_file_ipv4,
                                       cconst.TYPE_MOBILE,
                                       True,
                                       False,
                                       False)

    @test_tracker_info(uuid="565fc7e3-d7cf-43cc-8982-4f17999cf579")
    def test_wifi_tethering_mobile_data_usage_downlink_ipv6_vzw(self):
        """Verify mobile data usage with tethered device over IPv6 and VZW."""
        self._test_data_usage_downlink(self.android_devices[1],
                                       self.android_devices[0],
                                       self.download_file_ipv6,
                                       cconst.TYPE_MOBILE,
                                       True,
                                       False,
                                       False)

    @test_tracker_info(uuid="72ddb42a-5942-4a6a-8b20-2181c41b2765")
    def test_wifi_data_usage_downlink_ipv4(self):
        """Verify wifi data usage over IPv4."""
        self._test_data_usage_downlink(self.android_devices[0],
                                       self.android_devices[0],
                                       self.download_file_ipv4,
                                       cconst.TYPE_WIFI,
                                       False,
                                       True,
                                       True)

    @test_tracker_info(uuid="76b316f5-2946-4757-b5d6-62a8b1fd627e")
    def test_wifi_data_usage_downlink_ipv6(self):
        """Verify wifi data usage over IPv6."""
        self._test_data_usage_downlink(self.android_devices[0],
                                       self.android_devices[0],
                                       self.download_file_ipv6,
                                       cconst.TYPE_WIFI,
                                       False,
                                       True,
                                       True)

    @test_tracker_info(uuid="4be5f2d4-9bc6-4190-813e-044f00d94aa6")
    def test_wifi_tethering_wifi_data_usage_downlink_ipv4(self):
        """Verify wifi data usage with tethered device over IPv4."""
        asserts.skip_if(
            self.android_devices[0].model not in self.dbs_supported_models,
            "Device %s does not support dual interfaces." %
            self.android_devices[0].model)
        self._test_data_usage_downlink(self.android_devices[0],
                                       self.android_devices[1],
                                       self.download_file_ipv4,
                                       cconst.TYPE_WIFI,
                                       True,
                                       True,
                                       False)

    @test_tracker_info(uuid="ac4750fd-20d9-451d-a85b-79fdbaa7da97")
    def test_data_usage_limit_downlink_ipv4_tmo(self):
        """Verify data limit for TMO with IPv4 link."""
        self._test_data_usage_limit_downlink(self.android_devices[0],
                                             self.android_devices[0],
                                             self.download_file_ipv4,
                                             cconst.TYPE_MOBILE)

    @test_tracker_info(uuid="6598732e-f4d3-40c7-a73b-e89bb3d196c5")
    def test_data_usage_limit_downlink_ipv6_tmo(self):
        """Verify data limit for TMO with IPv6 link."""
        self._test_data_usage_limit_downlink(self.android_devices[0],
                                             self.android_devices[0],
                                             self.download_file_ipv6,
                                             cconst.TYPE_MOBILE)

    @test_tracker_info(uuid="d1ef0405-cf58-4141-94c7-cfa0c9d14438")
    def test_data_usage_limit_downlink_ipv4_vzw(self):
        """Verify data limit for VZW with IPv4 link."""
        self._test_data_usage_limit_downlink(self.android_devices[1],
                                             self.android_devices[1],
                                             self.download_file_ipv4,
                                             cconst.TYPE_MOBILE)

    @test_tracker_info(uuid="18d169d9-fc4f-4782-8f5f-fc96b8976d03")
    def test_data_usage_limit_downlink_ipv6_vzw(self):
        """Verify data limit for VZW with IPv6 link."""
        self._test_data_usage_limit_downlink(self.android_devices[1],
                                             self.android_devices[1],
                                             self.download_file_ipv6,
                                             cconst.TYPE_MOBILE)

    @test_tracker_info(uuid="7c9ab330-9645-4030-bb1e-dcce126944a2")
    def test_wifi_tethering_data_usage_limit_downlink_ipv4_tmo(self):
        """Verify data limit for TMO from tethered device with IPv4 link."""
        self._test_data_usage_limit_downlink(self.android_devices[0],
                                             self.android_devices[1],
                                             self.download_file_ipv4,
                                             cconst.TYPE_MOBILE,
                                             True)

    @test_tracker_info(uuid="1cafdaf7-a41e-4d19-b08a-ae094d796426")
    def test_wifi_tethering_data_usage_limit_downlink_ipv6_tmo(self):
        """Verify data limit for TMO from tethered device with IPv6 link."""
        self._test_data_usage_limit_downlink(self.android_devices[0],
                                             self.android_devices[1],
                                             self.download_file_ipv6,
                                             cconst.TYPE_MOBILE,
                                             True)

    @test_tracker_info(uuid="bd5a8f93-4e2f-474d-a01d-4bb5117d5350")
    def test_wifi_tethering_data_usage_limit_downlink_ipv4_vzw(self):
        """Verify data limit for VZW from tethered device with IPv4 link."""
        self._test_data_usage_limit_downlink(self.android_devices[1],
                                             self.android_devices[0],
                                             self.download_file_ipv4,
                                             cconst.TYPE_MOBILE,
                                             True)

    @test_tracker_info(uuid="ec082fe5-6af1-425e-ace6-4726930bf62f")
    def test_wifi_tethering_data_usage_limit_downlink_ipv6_vzw(self):
        """Verify data limit for VZW from tethered device with IPv6 link."""
        self._test_data_usage_limit_downlink(self.android_devices[1],
                                             self.android_devices[0],
                                             self.download_file_ipv6,
                                             cconst.TYPE_MOBILE,
                                             True)