/* * Copyright (C) 2019 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.tradefed.util; import com.android.tradefed.device.DeviceNotAvailableException; import com.android.tradefed.device.ITestDevice; import com.android.tradefed.log.LogUtil.CLog; import com.android.tradefed.util.sl4a.Sl4aClient; import com.android.tradefed.util.sl4a.Sl4aEventDispatcher.EventSl4aObject; import com.google.common.annotations.VisibleForTesting; import org.json.JSONArray; import org.json.JSONException; import org.json.JSONObject; import java.io.File; import java.io.IOException; import java.time.Duration; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; /** A utility class provides Bluetooth operations on one or two devices using SL4A */ public class Sl4aBluetoothUtil { private static final long BT_STATE_CHANGE_TIMEOUT_MS = 10000; private static final long BT_PAIRING_CHECK_INTERVAL_MS = 200; private static final long BT_CHECK_CONNECTION_INTERVAL_MS = 100; @VisibleForTesting static final String BT_SNOOP_LOG_CMD_LEGACY = "setprop persist.bluetooth.btsnoopenable %s"; @VisibleForTesting static final String BT_SNOOP_LOG_CMD = "setprop persist.bluetooth.btsnooplogmode %s"; /** Holding mappings from device serial number to the {@link Sl4aClient} of the device */ private Map mSl4aClients = new HashMap<>(); /** Holding mappings from {@link ITestDevice} instance to device MAC address */ private Map mAddresses = new HashMap<>(); private Duration mBtPairTimeout = Duration.ofSeconds(25); private Duration mBtConnectionTimeout = Duration.ofSeconds(15); /** SL4A RPC commands to be used for Bluetooth operations */ @VisibleForTesting static class Commands { static final String BLUETOOTH_CHECK_STATE = "bluetoothCheckState"; static final String BLUETOOTH_TOGGLE_STATE = "bluetoothToggleState"; static final String BLUETOOTH_GET_LOCAL_ADDRESS = "bluetoothGetLocalAddress"; static final String BLUETOOTH_GET_BONDED_DEVICES = "bluetoothGetBondedDevices"; static final String BLUETOOTH_MAKE_DISCOVERABLE = "bluetoothMakeDiscoverable"; static final String BLUETOOTH_GET_SCAN_MODE = "bluetoothGetScanMode"; static final String BLUETOOTH_START_PAIRING_HELPER = "bluetoothStartPairingHelper"; static final String BLUETOOTH_DISCOVER_AND_BOND = "bluetoothDiscoverAndBond"; static final String BLUETOOTH_UNBOND = "bluetoothUnbond"; static final String BLUETOOTH_START_CONNECTION_STATE_CHANGE_MONITOR = "bluetoothStartConnectionStateChangeMonitor"; static final String BLUETOOTH_CONNECT_BONDED = "bluetoothConnectBonded"; static final String BLUETOOTH_DISCONNECT_CONNECTED_PROFILE = "bluetoothDisconnectConnectedProfile"; static final String BLUETOOTH_HFP_CLIENT_GET_CONNECTED_DEVICES = "bluetoothHfpClientGetConnectedDevices"; static final String BLUETOOTH_A2DP_GET_CONNECTED_DEVICES = "bluetoothA2dpGetConnectedDevices"; static final String BLUETOOTH_A2DP_SINK_GET_CONNECTED_DEVICES = "bluetoothA2dpSinkGetConnectedDevices"; static final String BLUETOOTH_PBAP_CLIENT_GET_CONNECTED_DEVICES = "bluetoothPbapClientGetConnectedDevices"; static final String BLUETOOTH_PAN_GET_CONNECTED_DEVICES = "bluetoothPanGetConnectedDevices"; static final String BLUETOOTH_MAP_GET_CONNECTED_DEVICES = "bluetoothMapGetConnectedDevices"; static final String BLUETOOTH_MAP_CLIENT_GET_CONNECTED_DEVICES = "bluetoothMapClientGetConnectedDevices"; static final String BLUETOOTH_CHANGE_PROFILE_ACCESS_PERMISSION = "bluetoothChangeProfileAccessPermission"; static final String BLUETOOTH_A2DP_SINK_SET_PRIORITY = "bluetoothA2dpSinkSetPriority"; static final String BLUETOOTH_HFP_CLIENT_SET_PRIORITY = "bluetoothHfpClientSetPriority"; static final String BLUETOOTH_PBAP_CLIENT_SET_PRIORITY = "bluetoothPbapClientSetPriority"; } /** SL4A events to be used for Bluetooth */ @VisibleForTesting static class Events { static final String BLUETOOTH_STATE_CHANGED_ON = "BluetoothStateChangedOn"; static final String BLUETOOTH_STATE_CHANGED_OFF = "BluetoothStateChangedOff"; static final String BLUETOOTH_PROFILE_CONNECTION_STATE_CHANGED = "BluetoothProfileConnectionStateChanged"; } /** Enums for Bluetooth profiles which are based on {@code BluetoothProfile.java} */ public enum BluetoothProfile { HEADSET(1), A2DP(2), HID_HOST(4), PAN(5), PBAP(6), GATT(7), GATT_SERVER(8), MAP(9), SAP(10), A2DP_SINK(11), AVRCP_CONTROLLER(12), HEADSET_CLIENT(16), PBAP_CLIENT(17), MAP_CLIENT(18); private static final Map sProfileToValue = Stream.of(values()) .collect(Collectors.toMap(BluetoothProfile::getProfile, value -> value)); private final int mProfile; public static BluetoothProfile valueOfProfile(int profile) { return sProfileToValue.get(profile); } BluetoothProfile(int profile) { mProfile = profile; } public int getProfile() { return mProfile; } } /** Enums for Bluetooth connection states which are based on {@code BluetoothProfile.java} */ public enum BluetoothConnectionState { DISCONNECTED(0), CONNECTING(1), CONNECTED(2), DISCONNECTING(3); private final int mState; BluetoothConnectionState(int state) { mState = state; } public int getState() { return mState; } } /** Enums for Bluetooth device access level which are based on {@code BluetoothDevice.java} */ public enum BluetoothAccessLevel { ACCESS_UNKNOWN(0), ACCESS_ALLOWED(1), ACCESS_REJECTED(2); private final int mAccess; BluetoothAccessLevel(int access) { mAccess = access; } public int getAccess() { return mAccess; } } /** * Enums for Bluetooth profile priority level which are based on {@code BluetoothProfile.java} */ public enum BluetoothPriorityLevel { PRIORITY_AUTO_CONNECT(1000), PRIORITY_ON(100), PRIORITY_OFF(0), PRIORITY_UNDEFINED(-1); private final int mPriority; BluetoothPriorityLevel(int priority) { mPriority = priority; } public int getPriority() { return mPriority; } } public void setBtPairTimeout(Duration timeout) { mBtPairTimeout = timeout; } public void setBtConnectionTimeout(Duration timeout) { mBtConnectionTimeout = timeout; } /** * Explicitly start SL4A client with the given device and SL4A apk file. Normally this method is * not required, because SL4A connection will always be established before actual operations. * * @param device the device to be connected using SL4A * @param sl4aApkFile the optional SL4A apk to install and use. * @throws DeviceNotAvailableException */ public void startSl4a(ITestDevice device, File sl4aApkFile) throws DeviceNotAvailableException { Sl4aClient sl4aClient = Sl4aClient.startSL4A(device, sl4aApkFile); mSl4aClients.put(device.getSerialNumber(), sl4aClient); } /** * Stop SL4A clients that already being opened. It basically provide a way to cleanup clients * immediately after they are no longer used */ public void stopSl4a() { for (Map.Entry entry : mSl4aClients.entrySet()) { entry.getValue().close(); } mSl4aClients.clear(); } @VisibleForTesting void setSl4a(ITestDevice device, Sl4aClient client) { mSl4aClients.put(device.getSerialNumber(), client); } /** Clean up all SL4A connections */ @Override protected void finalize() { stopSl4a(); } /** * Enable Bluetooth on target device * * @param device target device * @return true if Bluetooth successfully enabled * @throws DeviceNotAvailableException */ public boolean enable(ITestDevice device) throws DeviceNotAvailableException { return toggleState(device, true); } /** * Disable Bluetooth on target device * * @param device target device * @return true if Bluetooth successfully disabled * @throws DeviceNotAvailableException */ public boolean disable(ITestDevice device) throws DeviceNotAvailableException { return toggleState(device, false); } /** * Get Bluetooth MAC Address of target device * * @param device target device * @return MAC Address string * @throws DeviceNotAvailableException */ public String getAddress(ITestDevice device) throws DeviceNotAvailableException { if (mAddresses.containsKey(device)) { return mAddresses.get(device); } Sl4aClient client = getSl4aClient(device); String address = null; try { address = (String) client.rpcCall(Commands.BLUETOOTH_GET_LOCAL_ADDRESS); mAddresses.put(device, address); } catch (IOException e) { CLog.e( "Failed to get Bluetooth MAC address on device: %s, %s", device.getSerialNumber(), e); } return address; } /** * Get set of Bluetooth MAC addresses of the bonded (paired) devices on the target device * * @param device target device * @return Set of Bluetooth MAC addresses * @throws DeviceNotAvailableException */ public Set getBondedDevices(ITestDevice device) throws DeviceNotAvailableException { Set addresses = new HashSet<>(); Sl4aClient client = getSl4aClient(device); try { Object response = client.rpcCall(Commands.BLUETOOTH_GET_BONDED_DEVICES); if (response != null) { JSONArray bondedDevices = (JSONArray) response; for (int i = 0; i < bondedDevices.length(); i++) { JSONObject bondedDevice = bondedDevices.getJSONObject(i); if (bondedDevice.has("address")) { addresses.add(bondedDevice.getString("address")); } } } } catch (IOException | JSONException e) { CLog.e("Failed to get bonded devices for device: %s, %s", device.getSerialNumber(), e); } return addresses; } /** * Pair primary device to secondary device * * @param primary device to pair from * @param secondary device to pair to * @return true if pairing is successful * @throws DeviceNotAvailableException */ public boolean pair(ITestDevice primary, ITestDevice secondary) throws DeviceNotAvailableException { Sl4aClient primaryClient = getSl4aClient(primary); Sl4aClient secondaryClient = getSl4aClient(secondary); try { if (isPaired(primary, secondary)) { CLog.i("The two devices are already paired."); return true; } CLog.d("Make secondary device discoverable"); secondaryClient.rpcCall(Commands.BLUETOOTH_MAKE_DISCOVERABLE); Integer response = (Integer) secondaryClient.rpcCall(Commands.BLUETOOTH_GET_SCAN_MODE); if (response != 3) { CLog.e("Scan mode is not CONNECTABLE_DISCOVERABLE"); return false; } CLog.d("Secondary device is made discoverable"); CLog.d("Start pairing helper on both devices"); primaryClient.rpcCall(Commands.BLUETOOTH_START_PAIRING_HELPER); secondaryClient.rpcCall(Commands.BLUETOOTH_START_PAIRING_HELPER); // Discover and bond (pair) companion device CLog.d("Start discover and bond to secondary device: %s", secondary.getSerialNumber()); primaryClient.getEventDispatcher().clearAllEvents(); primaryClient.rpcCall(Commands.BLUETOOTH_DISCOVER_AND_BOND, getAddress(secondary)); if (!waitUntilPaired(primary, secondary)) { CLog.e("Bluetooth pairing timeout"); return false; } } catch (IOException | InterruptedException e) { CLog.e("Error when pair two devices, %s", e); return false; } CLog.i("Secondary device successfully paired"); return true; } /** * Un-pair all paired devices for current device * * @param device Current device to perform the action * @return true if un-pair successfully * @throws DeviceNotAvailableException */ public boolean unpairAll(ITestDevice device) throws DeviceNotAvailableException { Set bondedDevices = getBondedDevices(device); Sl4aClient client = getSl4aClient(device); for (String address : bondedDevices) { try { Boolean res = (Boolean) client.rpcCall(Commands.BLUETOOTH_UNBOND, address); if (!res) { CLog.w( "Failed to unpair device %s. It may not be an actual failure, instead" + " it may be due to trying to unpair an already unpaired device." + " This usually happens when device was first connected using LE" + " transport where both LE address and classic address are paired" + " and unpaired at the same time.", address); } } catch (IOException e) { CLog.e("Failed to unpair all Bluetooth devices, %s", e); } } return getBondedDevices(device).isEmpty(); } /** * Connect primary device to secondary device on given Bluetooth profiles * * @param primary device to connect from * @param secondary device to connect to * @param profiles A set of Bluetooth profiles are required to be connected * @return true if connection are successful * @throws DeviceNotAvailableException */ public boolean connect( ITestDevice primary, ITestDevice secondary, Set profiles) throws DeviceNotAvailableException { if (!isPaired(primary, secondary)) { CLog.e("Primary device have not yet paired to secondary device"); return false; } CLog.d("Connecting to profiles: %s", profiles); Sl4aClient primaryClient = getSl4aClient(primary); String address = getAddress(secondary); try { primaryClient.rpcCall( Commands.BLUETOOTH_START_CONNECTION_STATE_CHANGE_MONITOR, address); primaryClient.rpcCall(Commands.BLUETOOTH_CONNECT_BONDED, address); Set connectedProfiles = waitForConnectedOrDisconnectedProfiles( primary, address, BluetoothConnectionState.CONNECTED, profiles); return waitForRemainingProfilesConnected(primary, address, connectedProfiles, profiles); } catch (IOException | InterruptedException | JSONException e) { CLog.e("Failed to connect to secondary device, %s", e); } return false; } /** * Disconnect primary device from secondary device * * @param primary device to perform disconnect operation * @param secondary device to be disconnected * @param profiles Given set of Bluetooth profiles required to be disconnected * @return true if disconnected successfully * @throws DeviceNotAvailableException */ public boolean disconnect( ITestDevice primary, ITestDevice secondary, Set profiles) throws DeviceNotAvailableException { CLog.d("Disconnecting to profiles: %s", profiles); Sl4aClient primaryClient = getSl4aClient(primary); String address = getAddress(secondary); try { primaryClient.rpcCall( Commands.BLUETOOTH_START_CONNECTION_STATE_CHANGE_MONITOR, address); primaryClient.rpcCall( Commands.BLUETOOTH_DISCONNECT_CONNECTED_PROFILE, address, new JSONArray( profiles.stream() .map(profile -> profile.getProfile()) .collect(Collectors.toList()))); Set disconnectedProfiles = waitForConnectedOrDisconnectedProfiles( primary, address, BluetoothConnectionState.DISCONNECTED, profiles); return waitForRemainingProfilesDisconnected( primary, address, disconnectedProfiles, profiles); } catch (IOException | JSONException | InterruptedException e) { CLog.e("Failed to disconnect from secondary device, %s", e); } return false; } /** * Enable Bluetooth snoop log * * @param device to enable snoop log * @return true if enabled successfully * @throws DeviceNotAvailableException */ public boolean enableBluetoothSnoopLog(ITestDevice device) throws DeviceNotAvailableException { if (isQAndAbove(device)) { device.executeShellCommand(String.format(BT_SNOOP_LOG_CMD, "full")); } else { device.executeShellCommand(String.format(BT_SNOOP_LOG_CMD_LEGACY, "true")); } return disable(device) && enable(device); } /** * Disable Bluetooth snoop log * * @param device to disable snoop log * @return true if disabled successfully * @throws DeviceNotAvailableException */ public boolean disableBluetoothSnoopLog(ITestDevice device) throws DeviceNotAvailableException { if (isQAndAbove(device)) { device.executeShellCommand(String.format(BT_SNOOP_LOG_CMD, "disabled")); } else { device.executeShellCommand(String.format(BT_SNOOP_LOG_CMD_LEGACY, "false")); } return disable(device) && enable(device); } /** * Change Bluetooth profile access permission of secondary device on primary device in order for * secondary device to access primary device on the given profile * * @param primary device to change permission * @param secondary device that accesses primary device on the given profile * @param profile Bluetooth profile to access * @param access level of access, see {@code BluetoothAccessLevel} * @return true if permission changed successfully * @throws DeviceNotAvailableException */ public boolean changeProfileAccessPermission( ITestDevice primary, ITestDevice secondary, BluetoothProfile profile, BluetoothAccessLevel access) throws DeviceNotAvailableException { Sl4aClient primaryClient = getSl4aClient(primary); String secondaryAddress = getAddress(secondary); try { primaryClient.rpcCall( Commands.BLUETOOTH_CHANGE_PROFILE_ACCESS_PERMISSION, secondaryAddress, profile.mProfile, access.getAccess()); } catch (IOException e) { CLog.e("Failed to set profile access level %s for profile %s, %s", access, profile, e); return false; } return true; } /** * Change priority setting of given profiles on primary device towards secondary device * * @param primary device to set priority on * @param secondary device to set priority for * @param profiles Bluetooth profiles to change priority setting * @param priority level of priority * @return true if set priority successfully * @throws DeviceNotAvailableException */ public boolean setProfilePriority( ITestDevice primary, ITestDevice secondary, Set profiles, BluetoothPriorityLevel priority) throws DeviceNotAvailableException { Sl4aClient primaryClient = getSl4aClient(primary); String secondaryAddress = getAddress(secondary); for (BluetoothProfile profile : profiles) { try { switch (profile) { case A2DP_SINK: primaryClient.rpcCall( Commands.BLUETOOTH_A2DP_SINK_SET_PRIORITY, secondaryAddress, priority.getPriority()); break; case HEADSET_CLIENT: primaryClient.rpcCall( Commands.BLUETOOTH_HFP_CLIENT_SET_PRIORITY, secondaryAddress, priority.getPriority()); break; case PBAP_CLIENT: primaryClient.rpcCall( Commands.BLUETOOTH_PBAP_CLIENT_SET_PRIORITY, secondaryAddress, priority.getPriority()); break; default: CLog.e("Profile %s is not yet supported for priority settings", profile); return false; } } catch (IOException e) { CLog.e("Failed to set profile %s with priority %s, %s", profile, priority, e); return false; } } return true; } private boolean toggleState(ITestDevice device, boolean targetState) throws DeviceNotAvailableException { Sl4aClient client = getSl4aClient(device); try { boolean currentState = (Boolean) client.rpcCall(Commands.BLUETOOTH_CHECK_STATE); if (currentState == targetState) { return true; } client.getEventDispatcher().clearAllEvents(); Boolean result = (Boolean) client.rpcCall(Commands.BLUETOOTH_TOGGLE_STATE, targetState); if (!result) { CLog.e( "Error in sl4a when toggling %s Bluetooth state.", targetState ? "ON" : "OFF"); return false; } String event = targetState ? Events.BLUETOOTH_STATE_CHANGED_ON : Events.BLUETOOTH_STATE_CHANGED_OFF; EventSl4aObject response = client.getEventDispatcher().popEvent(event, BT_STATE_CHANGE_TIMEOUT_MS); if (response == null) { CLog.e( "Get null response after toggling %s Bluetooth state.", targetState ? "ON" : "OFF"); return false; } } catch (IOException e) { CLog.e("Error when toggling %s Bluetooth state, %s", targetState ? "ON" : "OFF", e); return false; } return true; } private Sl4aClient getSl4aClient(ITestDevice device) throws DeviceNotAvailableException { String serial = device.getSerialNumber(); if (!mSl4aClients.containsKey(serial)) { Sl4aClient client = Sl4aClient.startSL4A(device, null); mSl4aClients.put(serial, client); } return mSl4aClients.get(serial); } private boolean waitUntilPaired(ITestDevice primary, ITestDevice secondary) throws InterruptedException, DeviceNotAvailableException { long endTime = System.currentTimeMillis() + mBtPairTimeout.toMillis(); while (System.currentTimeMillis() < endTime) { if (isPaired(primary, secondary)) { return true; } Thread.sleep(BT_PAIRING_CHECK_INTERVAL_MS); } return false; } private boolean isPaired(ITestDevice primary, ITestDevice secondary) throws DeviceNotAvailableException { return getBondedDevices(primary).contains(getAddress(secondary)); } private Set waitForConnectedOrDisconnectedProfiles( ITestDevice primary, String address, BluetoothConnectionState targetState, Set allProfiles) throws DeviceNotAvailableException, JSONException { Set targetProfiles = new HashSet<>(); Sl4aClient primaryClient = getSl4aClient(primary); // Check connection broadcast receiver while (!targetProfiles.containsAll(allProfiles)) { EventSl4aObject event = primaryClient .getEventDispatcher() .popEvent( Events.BLUETOOTH_PROFILE_CONNECTION_STATE_CHANGED, mBtConnectionTimeout.toMillis()); if (event == null) { CLog.w("Timeout while waiting for connection state changes for all profiles"); return targetProfiles; } JSONObject profileData = new JSONObject(event.getData()); int profile = profileData.getInt("profile"); int state = profileData.getInt("state"); String actualAddress = profileData.getString("addr"); if (state == targetState.getState() && address.equals(actualAddress)) { targetProfiles.add(BluetoothProfile.valueOfProfile(profile)); } } return targetProfiles; } private boolean waitForRemainingProfilesConnected( ITestDevice primary, String address, Set connectedProfiles, Set allProfiles) throws InterruptedException, DeviceNotAvailableException, JSONException, IOException { long endTime = System.currentTimeMillis() + mBtConnectionTimeout.toMillis(); while (System.currentTimeMillis() < endTime && !connectedProfiles.containsAll(allProfiles)) { for (BluetoothProfile profile : allProfiles) { if (connectedProfiles.contains(profile)) { continue; } if (isProfileConnected(primary, address, profile)) { connectedProfiles.add(profile); } CLog.d("Connected profiles for now: %s", connectedProfiles); } Thread.sleep(BT_CHECK_CONNECTION_INTERVAL_MS); } return connectedProfiles.containsAll(allProfiles); } private boolean waitForRemainingProfilesDisconnected( ITestDevice primary, String address, Set disConnectedProfiles, Set allProfiles) throws InterruptedException, DeviceNotAvailableException, JSONException, IOException { long endTime = System.currentTimeMillis() + mBtConnectionTimeout.toMillis(); while (System.currentTimeMillis() < endTime && !disConnectedProfiles.containsAll(allProfiles)) { for (BluetoothProfile profile : allProfiles) { if (disConnectedProfiles.contains(profile)) { continue; } if (!isProfileConnected(primary, address, profile)) { disConnectedProfiles.add(profile); } CLog.d("Disconnected profiles for now: %s", disConnectedProfiles); } Thread.sleep(BT_CHECK_CONNECTION_INTERVAL_MS); } return disConnectedProfiles.containsAll(allProfiles); } private boolean isProfileConnected( ITestDevice primary, String address, BluetoothProfile profile) throws DeviceNotAvailableException, IOException, JSONException { switch (profile) { case HEADSET_CLIENT: return checkConnectedDevice( primary, address, Commands.BLUETOOTH_HFP_CLIENT_GET_CONNECTED_DEVICES); case A2DP: return checkConnectedDevice( primary, address, Commands.BLUETOOTH_A2DP_GET_CONNECTED_DEVICES); case A2DP_SINK: return checkConnectedDevice( primary, address, Commands.BLUETOOTH_A2DP_SINK_GET_CONNECTED_DEVICES); case PAN: return checkConnectedDevice( primary, address, Commands.BLUETOOTH_PAN_GET_CONNECTED_DEVICES); case PBAP_CLIENT: return checkConnectedDevice( primary, address, Commands.BLUETOOTH_PBAP_CLIENT_GET_CONNECTED_DEVICES); case MAP: return checkConnectedDevice( primary, address, Commands.BLUETOOTH_MAP_GET_CONNECTED_DEVICES); case MAP_CLIENT: return checkConnectedDevice( primary, address, Commands.BLUETOOTH_MAP_CLIENT_GET_CONNECTED_DEVICES); default: CLog.e("Unsupported profile %s to check connection state", profile); } return false; } private boolean checkConnectedDevice(ITestDevice primary, String address, String sl4aCommand) throws DeviceNotAvailableException, IOException, JSONException { Sl4aClient primaryClient = getSl4aClient(primary); JSONArray devices = (JSONArray) primaryClient.rpcCall(sl4aCommand); if (devices == null) { CLog.e("Empty response"); return false; } for (int i = 0; i < devices.length(); i++) { JSONObject device = devices.getJSONObject(i); if (device.has("address") && device.getString("address").equals(address)) { return true; } } return false; } private boolean isQAndAbove(ITestDevice device) throws DeviceNotAvailableException { return device.getApiLevel() > 28; } }