Home | History | Annotate | Download | only in bt5
      1 #/usr/bin/env python3.4
      2 #
      3 # Copyright (C) 2017 The Android Open Source Project
      4 #
      5 # Licensed under the Apache License, Version 2.0 (the "License"); you may not
      6 # use this file except in compliance with the License. You may obtain a copy of
      7 # the License at
      8 #
      9 # http://www.apache.org/licenses/LICENSE-2.0
     10 #
     11 # Unless required by applicable law or agreed to in writing, software
     12 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
     13 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
     14 # License for the specific language governing permissions and limitations under
     15 # the License.
     16 """
     17 This test script exercises different Bluetooth 5 specific scan scenarios.
     18 It is expected that the second AndroidDevice is able to advertise.
     19 
     20 This test script was designed with this setup in mind:
     21 Shield box one: Android Device, Android Device
     22 """
     23 
     24 from queue import Empty
     25 
     26 from acts.asserts import assert_equal
     27 from acts.asserts import assert_true
     28 from acts.test_decorators import test_tracker_info
     29 from acts.test_utils.bt.BluetoothBaseTest import BluetoothBaseTest
     30 from acts.test_utils.bt.BleEnum import ScanSettingsPhy
     31 from acts.test_utils.bt.BleEnum import ScanSettingsScanMode
     32 from acts.test_utils.bt.bt_test_utils import advertising_set_started
     33 from acts.test_utils.bt.bt_test_utils import advertising_set_stopped
     34 from acts.test_utils.bt.bt_test_utils import advertising_set_enabled
     35 from acts.test_utils.bt.bt_test_utils import advertising_set_data_set
     36 from acts.test_utils.bt.bt_test_utils import advertising_set_scan_response_set
     37 from acts.test_utils.bt.bt_test_utils import advertising_set_parameters_update
     38 from acts.test_utils.bt.bt_test_utils import advertising_set_periodic_parameters_updated
     39 from acts.test_utils.bt.bt_test_utils import advertising_set_periodic_data_set
     40 from acts.test_utils.bt.bt_test_utils import advertising_set_periodic_enable
     41 from acts.test_utils.bt.bt_test_utils import reset_bluetooth
     42 from acts import signals
     43 
     44 
     45 class AdvertisingSetTest(BluetoothBaseTest):
     46     default_timeout = 10
     47     max_scan_instances = 28
     48     report_delay = 2000
     49     scan_callbacks = []
     50     adv_callbacks = []
     51     active_scan_callback_list = []
     52     big_adv_data = {
     53         "includeDeviceName": True,
     54         "manufacturerData": [0x0123, "00112233445566778899AABBCCDDEE"],
     55         "manufacturerData2":
     56         [0x2540, [0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xFF]],
     57         "serviceData": [
     58             "b19d42dc-58ba-4b20-b6c1-6628e7d21de4",
     59             "00112233445566778899AABBCCDDEE"
     60         ],
     61         "serviceData2": [
     62             "000042dc-58ba-4b20-b6c1-6628e7d21de4",
     63             [0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0xFF]
     64         ]
     65     }
     66 
     67     def __init__(self, controllers):
     68         BluetoothBaseTest.__init__(self, controllers)
     69         self.adv_ad = self.android_devices[0]
     70 
     71     def setup_class(self):
     72         if not self.adv_ad.droid.bluetoothIsLeExtendedAdvertisingSupported():
     73             raise signals.TestSkipClass(
     74                 "Advertiser does not support LE Extended Advertising")
     75 
     76     def teardown_test(self):
     77         self.active_scan_callback_list = []
     78 
     79     def on_exception(self, test_name, begin_time):
     80         reset_bluetooth(self.android_devices)
     81 
     82     @BluetoothBaseTest.bt_test_wrap
     83     @test_tracker_info(uuid='58182f7e-443f-47fb-b718-1be3ac850287')
     84     def test_reenabling(self):
     85         """Test re-enabling an Advertising Set
     86 
     87         Test GATT notify characteristic value.
     88 
     89         Steps:
     90         1. Start an advertising set that only lasts for a few seconds
     91         2. Restart advertising set
     92         3. Repeat steps 1-2
     93 
     94         Expected Result:
     95         Verify that advertising set re-enables
     96 
     97         Returns:
     98           Pass if True
     99           Fail if False
    100 
    101         TAGS: LE, GATT, Characteristic
    102         Priority: 1
    103         """
    104         adv_callback = self.adv_ad.droid.bleAdvSetGenCallback()
    105         duration = 0
    106         max_ext_adv_events = 0
    107         self.adv_ad.droid.bleAdvSetStartAdvertisingSet({
    108             "connectable": False,
    109             "legacyMode": False,
    110             "primaryPhy": "PHY_LE_1M",
    111             "secondaryPhy": "PHY_LE_1M",
    112             "interval": 320
    113         }, self.big_adv_data, None, None, None, duration, max_ext_adv_events,
    114                                                        adv_callback)
    115 
    116         set_started_evt = self.adv_ad.ed.pop_event(
    117             advertising_set_started.format(adv_callback), self.default_timeout)
    118         set_id = set_started_evt['data']['setId']
    119         assert_equal(0, set_started_evt['data']['status'])
    120         assert_equal(0, set_started_evt['data']['status'])
    121 
    122         self.log.info("Successfully started set " + str(set_id))
    123 
    124         self.adv_ad.droid.bleAdvSetEnableAdvertising(set_id, False, duration,
    125                                                      max_ext_adv_events)
    126         enable_evt = self.adv_ad.ed.pop_event(
    127             advertising_set_enabled.format(adv_callback), self.default_timeout)
    128         assert_equal(set_id, enable_evt['data']['setId'])
    129         assert_equal(False, enable_evt['data']['enable'])
    130         assert_equal(0, enable_evt['data']['status'])
    131         self.log.info("Successfully disabled advertising set " + str(set_id))
    132 
    133         self.log.info("Enabling advertising for 2 seconds... ")
    134         duration_200 = 200
    135         self.adv_ad.droid.bleAdvSetEnableAdvertising(
    136             set_id, True, duration_200, max_ext_adv_events)
    137         enable_evt = self.adv_ad.ed.pop_event(
    138             advertising_set_enabled.format(adv_callback), self.default_timeout)
    139         assert_equal(set_id, enable_evt['data']['setId'])
    140         assert_equal(True, enable_evt['data']['enable'])
    141         assert_equal(0, enable_evt['data']['status'])
    142         self.log.info("Enabled. Waiting for disable event ~2s ...")
    143 
    144         enable_evt = self.adv_ad.ed.pop_event(
    145             advertising_set_enabled.format(adv_callback), self.default_timeout)
    146         assert_equal(set_id, enable_evt['data']['setId'])
    147         assert_equal(False, enable_evt['data']['enable'])
    148         assert_equal(0, enable_evt['data']['status'])
    149         self.log.info("Disable event received. Now trying to set data...")
    150 
    151         self.adv_ad.droid.bleAdvSetSetAdvertisingData(
    152             set_id,
    153             {"manufacturerData": [0x0123, "00112233445566778899AABBCCDDEE"]})
    154         data_set_evt = self.adv_ad.ed.pop_event(
    155             advertising_set_data_set.format(adv_callback),
    156             self.default_timeout)
    157         assert_equal(set_id, data_set_evt['data']['setId'])
    158         assert_equal(0, data_set_evt['data']['status'])
    159         self.log.info("Data changed successfully.")
    160 
    161         max_len = self.adv_ad.droid.bluetoothGetLeMaximumAdvertisingDataLength(
    162         )
    163 
    164         self.log.info("Will try to set data to maximum possible length")
    165         data_len = max_len - 4
    166         test_fill = '01' * data_len
    167         self.adv_ad.droid.bleAdvSetSetAdvertisingData(
    168             set_id, {"manufacturerData": [0x0123, test_fill]})
    169         data_set_evt = self.adv_ad.ed.pop_event(
    170             advertising_set_data_set.format(adv_callback),
    171             self.default_timeout)
    172         assert_equal(set_id, data_set_evt['data']['setId'])
    173         assert_equal(0, data_set_evt['data']['status'])
    174         self.log.info("Data changed successfully.")
    175 
    176         if max_len < 1650:
    177             self.log.info("Will try to set data to more than maximum length")
    178             data_len = max_len - 4 + 1
    179             test_fill = '01' * data_len
    180             self.adv_ad.droid.bleAdvSetSetAdvertisingData(
    181                 set_id, {"manufacturerData": [0x0123, test_fill]})
    182             data_set_evt = self.adv_ad.ed.pop_event(
    183                 advertising_set_data_set.format(adv_callback),
    184                 self.default_timeout)
    185             assert_equal(set_id, data_set_evt['data']['setId'])
    186             #TODO(jpawlowski): make nicer error fot this case
    187             assert_true(data_set_evt['data']['status'] != 0,
    188                         "Setting data should fail because data too long.")
    189 
    190             self.log.info("Data change failed as expected.")
    191 
    192         self.adv_ad.droid.bleAdvSetStopAdvertisingSet(adv_callback)
    193         try:
    194             self.adv_ad.ed.pop_event(
    195                 advertising_set_stopped.format(adv_callback),
    196                 self.default_timeout)
    197         except Empty:
    198             self.log.error("Failed to find advertising set stopped event.")
    199             return False
    200         return True
    201