1#!/usr/bin/env python3
2#
3# Copyright (C) 2016 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"""
17GATT Client Libraries
18"""
19
20from acts_contrib.test_utils.bt.bt_constants import default_le_connection_interval_ms
21from acts_contrib.test_utils.bt.bt_constants import default_bluetooth_socket_timeout_ms
22from acts_contrib.test_utils.bt.bt_gatt_utils import disconnect_gatt_connection
23from acts_contrib.test_utils.bt.bt_gatt_utils import setup_gatt_connection
24from acts_contrib.test_utils.bt.bt_gatt_utils import setup_gatt_mtu
25from acts_contrib.test_utils.bt.bt_constants import ble_scan_settings_modes
26from acts_contrib.test_utils.bt.bt_constants import gatt_cb_strings
27from acts_contrib.test_utils.bt.bt_constants import gatt_char_desc_uuids
28from acts_contrib.test_utils.bt.bt_constants import gatt_descriptor
29from acts_contrib.test_utils.bt.bt_constants import gatt_transport
30from acts_contrib.test_utils.bt.bt_constants import le_default_supervision_timeout
31from acts_contrib.test_utils.bt.bt_constants import le_connection_interval_time_step_ms
32from acts_contrib.test_utils.bt.bt_constants import scan_result
33from acts_contrib.test_utils.bt.bt_gatt_utils import log_gatt_server_uuids
34
35import time
36
37
38class GattClientLib():
39    def __init__(self, log, dut, target_mac_addr=None):
40        self.dut = dut
41        self.log = log
42        self.gatt_callback = None
43        self.bluetooth_gatt = None
44        self.discovered_services_index = None
45        self.target_mac_addr = target_mac_addr
46        self.generic_uuid = "0000{}-0000-1000-8000-00805f9b34fb"
47
48    def set_target_mac_addr(self, mac_addr):
49        self.target_mac_addr = mac_addr
50
51    def connect_over_le_based_off_name(self, autoconnect, name):
52        """Perform GATT connection over LE"""
53        self.dut.droid.bleSetScanSettingsScanMode(
54            ble_scan_settings_modes['low_latency'])
55        filter_list = self.dut.droid.bleGenFilterList()
56        scan_settings = self.dut.droid.bleBuildScanSetting()
57        scan_callback = self.dut.droid.bleGenScanCallback()
58        event_name = scan_result.format(scan_callback)
59        self.dut.droid.bleSetScanFilterDeviceName("BLE Rect")
60        self.dut.droid.bleBuildScanFilter(filter_list)
61        self.dut.droid.bleStartBleScan(filter_list, scan_settings,
62                                       scan_callback)
63
64        try:
65            event = self.dut.ed.pop_event(event_name, 10)
66            self.log.info("Found scan result: {}".format(event))
67        except Exception:
68            self.log.info("Didn't find any scan results.")
69        mac_addr = event['data']['Result']['deviceInfo']['address']
70        self.bluetooth_gatt, self.gatt_callback = setup_gatt_connection(
71            self.dut, mac_addr, autoconnect, transport=gatt_transport['le'])
72        self.dut.droid.bleStopBleScan(scan_callback)
73        self.discovered_services_index = None
74
75    def connect_over_le(self, autoconnect):
76        """Perform GATT connection over LE"""
77        self.bluetooth_gatt, self.gatt_callback = setup_gatt_connection(
78            self.dut,
79            self.target_mac_addr,
80            autoconnect,
81            transport=gatt_transport['le'])
82        self.discovered_services_index = None
83
84    def connect_over_bredr(self):
85        """Perform GATT connection over BREDR"""
86        self.bluetooth_gatt, self.gatt_callback = setup_gatt_connection(
87            self.dut,
88            self.target_mac_addr,
89            False,
90            transport=gatt_transport['bredr'])
91
92    def disconnect(self):
93        """Perform GATT disconnect"""
94        cmd = "Disconnect GATT connection"
95        try:
96            disconnect_gatt_connection(self.dut, self.bluetooth_gatt,
97                                       self.gatt_callback)
98        except Exception as err:
99            self.log.info("Cmd {} failed with {}".format(cmd, err))
100        try:
101            self.dut.droid.gattClientClose(self.bluetooth_gatt)
102        except Exception as err:
103            self.log.info("Cmd failed with {}".format(err))
104
105    def _setup_discovered_services_index(self):
106        if not self.discovered_services_index:
107            self.dut.droid.gattClientDiscoverServices(self.bluetooth_gatt)
108            expected_event = gatt_cb_strings['gatt_serv_disc'].format(
109                self.gatt_callback)
110            event = self.dut.ed.pop_event(expected_event, 10)
111            self.discovered_services_index = event['data']['ServicesIndex']
112
113    def read_char_by_uuid(self, line):
114        """GATT client read Characteristic by UUID."""
115        uuid = line
116        if len(line) == 4:
117            uuid = self.generic_uuid.format(line)
118        self.dut.droid.gattClientReadUsingCharacteristicUuid(
119            self.bluetooth_gatt, uuid, 0x0001, 0xFFFF)
120
121    def request_mtu(self, mtu):
122        """Request MTU Change of input value"""
123        setup_gatt_mtu(self.dut, self.bluetooth_gatt, self.gatt_callback,
124                       int(mtu))
125
126    def list_all_uuids(self):
127        """From the GATT Client, discover services and list all services,
128        chars and descriptors
129        """
130        self._setup_discovered_services_index()
131        log_gatt_server_uuids(self.dut, self.discovered_services_index,
132                              self.bluetooth_gatt)
133
134    def discover_services(self):
135        """GATT Client discover services of GATT Server"""
136        self.dut.droid.gattClientDiscoverServices(self.bluetooth_gatt)
137
138    def refresh(self):
139        """Perform Gatt Client Refresh"""
140        self.dut.droid.gattClientRefresh(self.bluetooth_gatt)
141
142    def read_char_by_instance_id(self, id):
143        """From the GATT Client, discover services and list all services,
144        chars and descriptors
145        """
146        if not id:
147            self.log.info("Invalid id")
148            return
149        self._setup_discovered_services_index()
150        self.dut.droid.gattClientReadCharacteristicByInstanceId(
151            self.bluetooth_gatt, self.discovered_services_index, int(id, 16))
152
153    def write_char_by_instance_id(self, line):
154        """GATT Client Write to Characteristic by instance ID"""
155        args = line.split()
156        if len(args) != 2:
157            self.log.info("2 Arguments required: [InstanceId] [Size]")
158            return
159        instance_id = args[0]
160        size = args[1]
161        write_value = []
162        for i in range(int(size)):
163            write_value.append(i % 256)
164        self._setup_discovered_services_index()
165        self.dut.droid.gattClientWriteCharacteristicByInstanceId(
166            self.bluetooth_gatt, self.discovered_services_index,
167            int(instance_id, 16), write_value)
168
169    def write_char_by_instance_id_value(self, line):
170        """GATT Client Write to Characteristic by instance ID"""
171        args = line.split()
172        if len(args) != 2:
173            self.log.info("2 Arguments required: [InstanceId] [Size]")
174            return
175        instance_id = args[0]
176        write_value = args[1]
177        self._setup_discovered_services_index()
178        self.dut.droid.gattClientWriteCharacteristicByInstanceId(
179            self.bluetooth_gatt, self.discovered_services_index,
180            int(instance_id, 16), [int(write_value)])
181
182    def mod_write_char_by_instance_id(self, line):
183        """GATT Client Write to Char that doesn't have write permission"""
184        args = line.split()
185        if len(args) != 2:
186            self.log.info("2 Arguments required: [InstanceId] [Size]")
187            return
188        instance_id = args[0]
189        size = args[1]
190        write_value = []
191        for i in range(int(size)):
192            write_value.append(i % 256)
193        self._setup_discovered_services_index()
194        self.dut.droid.gattClientModifyAccessAndWriteCharacteristicByInstanceId(
195            self.bluetooth_gatt, self.discovered_services_index,
196            int(instance_id, 16), write_value)
197
198    def write_invalid_char_by_instance_id(self, line):
199        """GATT Client Write to Char that doesn't exists"""
200        args = line.split()
201        if len(args) != 2:
202            self.log.info("2 Arguments required: [InstanceId] [Size]")
203            return
204        instance_id = args[0]
205        size = args[1]
206        write_value = []
207        for i in range(int(size)):
208            write_value.append(i % 256)
209        self._setup_discovered_services_index()
210        self.dut.droid.gattClientWriteInvalidCharacteristicByInstanceId(
211            self.bluetooth_gatt, self.discovered_services_index,
212            int(instance_id, 16), write_value)
213
214    def mod_read_char_by_instance_id(self, line):
215        """GATT Client Read Char that doesn't have write permission"""
216        instance_id = line
217        self._setup_discovered_services_index()
218        self.dut.droid.gattClientModifyAccessAndReadCharacteristicByInstanceId(
219            self.bluetooth_gatt, self.discovered_services_index,
220            int(instance_id, 16))
221
222    def read_invalid_char_by_instance_id(self, line):
223        """GATT Client Read Char that doesn't exists"""
224        instance_id = line
225        self.dut.droid.gattClientReadInvalidCharacteristicByInstanceId(
226            self.bluetooth_gatt, self.discovered_services_index,
227            int(instance_id, 16))
228
229    def mod_write_desc_by_instance_id(self, line):
230        """GATT Client Write to Desc that doesn't have write permission"""
231        cmd = ""
232        args = line.split()
233        if len(args) != 2:
234            self.log.info("2 Arguments required: [InstanceId] [Size]")
235            return
236        instance_id = args[0]
237        size = args[1]
238        write_value = []
239        for i in range(int(size)):
240            write_value.append(i % 256)
241        self._setup_discovered_services_index()
242        self.dut.droid.gattClientModifyAccessAndWriteDescriptorByInstanceId(
243            self.bluetooth_gatt, self.discovered_services_index,
244            int(instance_id, 16), write_value)
245
246    def write_invalid_desc_by_instance_id(self, line):
247        """GATT Client Write to Desc that doesn't exists"""
248        args = line.split()
249        if len(args) != 2:
250            self.log.info("2 Arguments required: [InstanceId] [Size]")
251            return
252        instance_id = args[0]
253        size = args[1]
254        write_value = []
255        for i in range(int(size)):
256            write_value.append(i % 256)
257        self._setup_discovered_services_index()
258        self.dut.droid.gattClientWriteInvalidDescriptorByInstanceId(
259            self.bluetooth_gatt, self.discovered_services_index,
260            int(instance_id, 16), write_value)
261
262    def mod_read_desc_by_instance_id(self, line):
263        """GATT Client Read Desc that doesn't have write permission"""
264        cmd = ""
265        instance_id = line
266        self._setup_discovered_services_index()
267        self.dut.droid.gattClientModifyAccessAndReadDescriptorByInstanceId(
268            self.bluetooth_gatt, self.discovered_services_index,
269            int(instance_id, 16))
270
271    def read_invalid_desc_by_instance_id(self, line):
272        """GATT Client Read Desc that doesn't exists"""
273        instance_id = line
274        self._setup_discovered_services_index()
275        self.dut.droid.gattClientReadInvalidDescriptorByInstanceId(
276            self.bluetooth_gatt, self.discovered_services_index,
277            int(instance_id, 16))
278
279    def mod_read_char_by_uuid_and_instance_id(self, line):
280        """GATT Client Read Char that doesn't have write permission"""
281        args = line.split()
282        if len(args) != 2:
283            self.log.info("2 Arguments required: [uuid] [instance_id]")
284            return
285        uuid = args[0]
286        instance_id = args[1]
287        self._setup_discovered_services_index()
288        self.dut.droid.gattClientModifyAccessAndReadCharacteristicByUuidAndInstanceId(
289            self.bluetooth_gatt, self.discovered_services_index,
290            int(instance_id, 16), self.generic_uuid.format(uuid))
291
292    def read_invalid_char_by_uuid(self, line):
293        """GATT Client Read Char that doesn't exists"""
294        uuid = line
295        self._setup_discovered_services_index()
296        self.dut.droid.gattClientReadInvalidCharacteristicByUuid(
297            self.bluetooth_gatt, self.discovered_services_index,
298            self.generic_uuid.format(uuid))
299
300    def write_desc_by_instance_id(self, line):
301        """GATT Client Write to Descriptor by instance ID"""
302        args = line.split()
303        if len(args) != 2:
304            self.log.info("2 Arguments required: [instanceID] [size]")
305            return
306        instance_id = args[0]
307        size = args[1]
308        write_value = []
309        for i in range(int(size)):
310            write_value.append(i % 256)
311        self._setup_discovered_services_index()
312        self.dut.droid.gattClientWriteDescriptorByInstanceId(
313            self.bluetooth_gatt, self.discovered_services_index,
314            int(instance_id, 16), write_value)
315
316    def write_desc_notification_by_instance_id(self, line):
317        """GATT Client Write to Descriptor by instance ID"""
318        args = line.split()
319        instance_id = args[0]
320        switch = int(args[1])
321        write_value = [0x00, 0x00]
322        if switch == 2:
323            write_value = [0x02, 0x00]
324        self._setup_discovered_services_index()
325        self.dut.droid.gattClientWriteDescriptorByInstanceId(
326            self.bluetooth_gatt, self.discovered_services_index,
327            int(instance_id, 16), write_value)
328
329    def enable_notification_desc_by_instance_id(self, line):
330        """GATT Client Enable Notification on Descriptor by instance ID"""
331        instance_id = line
332        self._setup_discovered_services_index()
333        services_count = self.dut.droid.gattClientGetDiscoveredServicesCount(
334            self.discovered_services_index)
335        for i in range(services_count):
336            characteristic_uuids = (
337                self.dut.droid.gattClientGetDiscoveredCharacteristicUuids(
338                    self.discovered_services_index, i))
339            for j in range(len(characteristic_uuids)):
340                descriptor_uuids = (
341                    self.dut.droid.
342                    gattClientGetDiscoveredDescriptorUuidsByIndex(
343                        self.discovered_services_index, i, j))
344                for k in range(len(descriptor_uuids)):
345                    desc_inst_id = self.dut.droid.gattClientGetDescriptorInstanceId(
346                        self.bluetooth_gatt, self.discovered_services_index, i,
347                        j, k)
348                    if desc_inst_id == int(instance_id, 16):
349                        self.dut.droid.gattClientDescriptorSetValueByIndex(
350                            self.bluetooth_gatt,
351                            self.discovered_services_index, i, j, k,
352                            gatt_descriptor['enable_notification_value'])
353                        time.sleep(2)  #Necessary for PTS
354                        self.dut.droid.gattClientWriteDescriptorByIndex(
355                            self.bluetooth_gatt,
356                            self.discovered_services_index, i, j, k)
357                        time.sleep(2)  #Necessary for PTS
358                        self.dut.droid.gattClientSetCharacteristicNotificationByIndex(
359                            self.bluetooth_gatt,
360                            self.discovered_services_index, i, j, True)
361
362    def enable_indication_desc_by_instance_id(self, line):
363        """GATT Client Enable indication on Descriptor by instance ID"""
364        instance_id = line
365        self._setup_discovered_services_index()
366        services_count = self.dut.droid.gattClientGetDiscoveredServicesCount(
367            self.discovered_services_index)
368        for i in range(services_count):
369            characteristic_uuids = (
370                self.dut.droid.gattClientGetDiscoveredCharacteristicUuids(
371                    self.discovered_services_index, i))
372            for j in range(len(characteristic_uuids)):
373                descriptor_uuids = (
374                    self.dut.droid.
375                    gattClientGetDiscoveredDescriptorUuidsByIndex(
376                        self.discovered_services_index, i, j))
377                for k in range(len(descriptor_uuids)):
378                    desc_inst_id = self.dut.droid.gattClientGetDescriptorInstanceId(
379                        self.bluetooth_gatt, self.discovered_services_index, i,
380                        j, k)
381                    if desc_inst_id == int(instance_id, 16):
382                        self.dut.droid.gattClientDescriptorSetValueByIndex(
383                            self.bluetooth_gatt,
384                            self.discovered_services_index, i, j, k,
385                            gatt_descriptor['enable_indication_value'])
386                        time.sleep(2)  #Necessary for PTS
387                        self.dut.droid.gattClientWriteDescriptorByIndex(
388                            self.bluetooth_gatt,
389                            self.discovered_services_index, i, j, k)
390                        time.sleep(2)  #Necessary for PTS
391                        self.dut.droid.gattClientSetCharacteristicNotificationByIndex(
392                            self.bluetooth_gatt,
393                            self.discovered_services_index, i, j, True)
394
395    def char_enable_all_notifications(self):
396        self._setup_discovered_services_index()
397        services_count = self.dut.droid.gattClientGetDiscoveredServicesCount(
398            self.discovered_services_index)
399        for i in range(services_count):
400            characteristic_uuids = (
401                self.dut.droid.gattClientGetDiscoveredCharacteristicUuids(
402                    self.discovered_services_index, i))
403            for j in range(len(characteristic_uuids)):
404                self.dut.droid.gattClientSetCharacteristicNotificationByIndex(
405                    self.bluetooth_gatt, self.discovered_services_index, i, j,
406                    True)
407
408    def read_char_by_invalid_instance_id(self, line):
409        self._setup_discovered_services_index()
410        services_count = self.dut.droid.gattClientGetDiscoveredServicesCount(
411            self.discovered_services_index)
412        self.dut.droid.gattClientReadInvalidCharacteristicInstanceId(
413            self.bluetooth_gatt, self.discovered_services_index, 0,
414            int(line, 16))
415
416    def begin_reliable_write(self):
417        """Begin a reliable write on the Bluetooth Gatt Client"""
418        self.dut.droid.gattClientBeginReliableWrite(self.bluetooth_gatt)
419
420    def abort_reliable_write(self):
421        """Abort a reliable write on the Bluetooth Gatt Client"""
422        self.dut.droid.gattClientAbortReliableWrite(self.bluetooth_gatt)
423
424    def execute_reliable_write(self):
425        """Execute a reliable write on the Bluetooth Gatt Client"""
426        self.dut.droid.gattExecuteReliableWrite(self.bluetooth_gatt)
427
428    def read_all_char(self):
429        """GATT Client read all Characteristic values"""
430        self._setup_discovered_services_index()
431        services_count = self.dut.droid.gattClientGetDiscoveredServicesCount(
432            self.discovered_services_index)
433        for i in range(services_count):
434            characteristic_uuids = (
435                self.dut.droid.gattClientGetDiscoveredCharacteristicUuids(
436                    self.discovered_services_index, i))
437            for j in range(len(characteristic_uuids)):
438                char_inst_id = self.dut.droid.gattClientGetCharacteristicInstanceId(
439                    self.bluetooth_gatt, self.discovered_services_index, i, j)
440                self.log.info("Reading characteristic {} {}".format(
441                    hex(char_inst_id), characteristic_uuids[j]))
442                self.dut.droid.gattClientReadCharacteristicByIndex(
443                    self.bluetooth_gatt, self.discovered_services_index, i, j)
444                time.sleep(1)  # Necessary for PTS
445
446    def read_all_desc(self):
447        """GATT Client read all Descriptor values"""
448        self._setup_discovered_services_index()
449        services_count = self.dut.droid.gattClientGetDiscoveredServicesCount(
450            self.discovered_services_index)
451        for i in range(services_count):
452            characteristic_uuids = (
453                self.dut.droid.gattClientGetDiscoveredCharacteristicUuids(
454                    self.discovered_services_index, i))
455            for j in range(len(characteristic_uuids)):
456                descriptor_uuids = (
457                    self.dut.droid.
458                    gattClientGetDiscoveredDescriptorUuidsByIndex(
459                        self.discovered_services_index, i, j))
460                for k in range(len(descriptor_uuids)):
461                    time.sleep(1)
462                    try:
463                        self.log.info("Reading descriptor {}".format(
464                            descriptor_uuids[k]))
465                        self.dut.droid.gattClientReadDescriptorByIndex(
466                            self.bluetooth_gatt,
467                            self.discovered_services_index, i, j, k)
468                    except Exception as err:
469                        self.log.info(
470                            "Failed to read to descriptor: {}".format(
471                                descriptor_uuids[k]))
472
473    def write_all_char(self, line):
474        """Write to every Characteristic on the GATT server"""
475        args = line.split()
476        write_value = []
477        for i in range(int(line)):
478            write_value.append(i % 256)
479        self._setup_discovered_services_index()
480        services_count = self.dut.droid.gattClientGetDiscoveredServicesCount(
481            self.discovered_services_index)
482        for i in range(services_count):
483            characteristic_uuids = (
484                self.dut.droid.gattClientGetDiscoveredCharacteristicUuids(
485                    self.discovered_services_index, i))
486            for j in range(len(characteristic_uuids)):
487                char_inst_id = self.dut.droid.gattClientGetCharacteristicInstanceId(
488                    self.bluetooth_gatt, self.discovered_services_index, i, j)
489                self.log.info("Writing to {} {}".format(
490                    hex(char_inst_id), characteristic_uuids[j]))
491                try:
492                    self.dut.droid.gattClientCharacteristicSetValueByIndex(
493                        self.bluetooth_gatt, self.discovered_services_index, i,
494                        j, write_value)
495                    self.dut.droid.gattClientWriteCharacteristicByIndex(
496                        self.bluetooth_gatt, self.discovered_services_index, i,
497                        j)
498                    time.sleep(1)
499                except Exception as err:
500                    self.log.info(
501                        "Failed to write to characteristic: {}".format(
502                            characteristic_uuids[j]))
503
504    def write_all_desc(self, line):
505        """ Write to every Descriptor on the GATT server """
506        args = line.split()
507        write_value = []
508        for i in range(int(line)):
509            write_value.append(i % 256)
510        self._setup_discovered_services_index()
511        services_count = self.dut.droid.gattClientGetDiscoveredServicesCount(
512            self.discovered_services_index)
513        for i in range(services_count):
514            characteristic_uuids = (
515                self.dut.droid.gattClientGetDiscoveredCharacteristicUuids(
516                    self.discovered_services_index, i))
517            for j in range(len(characteristic_uuids)):
518                descriptor_uuids = (
519                    self.dut.droid.
520                    gattClientGetDiscoveredDescriptorUuidsByIndex(
521                        self.discovered_services_index, i, j))
522                for k in range(len(descriptor_uuids)):
523                    time.sleep(1)
524                    desc_inst_id = self.dut.droid.gattClientGetDescriptorInstanceId(
525                        self.bluetooth_gatt, self.discovered_services_index, i,
526                        j, k)
527                    self.log.info("Writing to {} {}".format(
528                        hex(desc_inst_id), descriptor_uuids[k]))
529                    try:
530                        self.dut.droid.gattClientDescriptorSetValueByIndex(
531                            self.bluetooth_gatt,
532                            self.discovered_services_index, i, j, k,
533                            write_value)
534                        self.dut.droid.gattClientWriteDescriptorByIndex(
535                            self.bluetooth_gatt,
536                            self.discovered_services_index, i, j, k)
537                    except Exception as err:
538                        self.log.info(
539                            "Failed to write to descriptor: {}".format(
540                                descriptor_uuids[k]))
541
542    def discover_service_by_uuid(self, line):
543        """ Discover service by UUID """
544        uuid = line
545        if len(line) == 4:
546            uuid = self.generic_uuid.format(line)
547        self.dut.droid.gattClientDiscoverServiceByUuid(self.bluetooth_gatt,
548                                                       uuid)
549
550    def request_le_connection_parameters(self):
551        le_min_ce_len = 0
552        le_max_ce_len = 0
553        le_connection_interval = 0
554        minInterval = default_le_connection_interval_ms / le_connection_interval_time_step_ms
555        maxInterval = default_le_connection_interval_ms / le_connection_interval_time_step_ms
556        return_status = self.dut.droid.gattClientRequestLeConnectionParameters(
557            self.bluetooth_gatt, minInterval, maxInterval, 0,
558            le_default_supervision_timeout, le_min_ce_len, le_max_ce_len)
559        self.log.info(
560            "Result of request le connection param: {}".format(return_status))
561
562    def socket_conn_begin_connect_thread_psm(self, line):
563        args = line.split()
564        is_ble = bool(int(args[0]))
565        secured_conn = bool(int(args[1]))
566        psm_value = int(args[2])  # 1
567        self.dut.droid.bluetoothSocketConnBeginConnectThreadPsm(
568            self.target_mac_addr, is_ble, psm_value, secured_conn)
569
570    def socket_conn_begin_accept_thread_psm(self, line):
571        accept_timeout_ms = default_bluetooth_socket_timeout_ms
572        is_ble = True
573        secured_conn = False
574        self.dut.droid.bluetoothSocketConnBeginAcceptThreadPsm(
575            accept_timeout_ms, is_ble, secured_conn)
576