An administrator can call this API to activate or deactivate Bluetooth blacklist and whitelist device restrictions.

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. An administrator can use this API to activate or deactivate Bluetooth blacklist and whitelist UUID restrictions.

An administrator can use this API to blacklist connections based on the Bluetooth device. Connections with matching device are prevented. The device is identified by the MAC address. During specification, only the "*" wildcard is allowed, which blacklists all devices except those in the whitelist. The blacklist takes effect only after being activated using activateBluetoothDeviceRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 //device to be removed from black list.
 List devices = new ArrayList();
 devices.add("00:11:22:33:AA:BB");
 devices.add("00:11:22:88:AA:CC"};
 try {
     boolean result = bluetoothPolicy.addBluetoothDevicesToBlackList(devices);
     if (true == result) {
         //device successfully added to blacklist
     } else {
         //device not added to blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to add connections to a whitelist based on the Bluetooth device. A connection with a matching device is an exception from the blacklist. During specification, only the "*" wildcard is allowed, which adds all devices to the whitelist. If the same UUID is present in the whitelist and blacklist and was added by same administrator, the whitelist takes priority. The whitelist takes effect only after being activated using activateBluetoothDeviceRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 //device to be removed from white list.
 List devices = new ArrayList();
 devices.add("00:11:22:33:AA:BB");
 devices.add("00:11:22:88:AA:CC"};
 try {
     boolean result = bluetoothPolicy.addBluetoothDevicesToWhiteList(devices);
     if (true == result) {
         //device added to whitelist
     } else {
         //device not added to whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to add connections to a whitelist based on the Bluetooth device. If defaultBlackList is true, then by default all other devices are blacklisted other than whitlisted devices. A connection with a matching device is an exception from the blacklist. During specification, only the "*" wildcard is allowed, which adds all devices to the whitelist. If the same UUID is present in the whitelist and blacklist and was added by same administrator, the whitelist takes priority. The whitelist takes effect only after being activated using activateBluetoothDeviceRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 //device to be removed from white list.
 List devices = new ArrayList();
 devices.add("00:11:22:33:AA:BB");
 devices.add("00:11:22:88:AA:CC"};
 boolean defaultBlackList = true;
 try {
     boolean result = bluetoothPolicy.addBluetoothDevicesToWhiteList(devices,defaultBlackList);
     if (true == result) {
         //device added to whitelist
     } else {
         //device not added to whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Bluetooth UUIDs represent features offered by devices. For interoperability, two communicating devices must implement a common profile. An administrator can use this API to blacklist connections based on Bluetooth UUIDs. Connections with matching UUID are prevented. During specification, only the "*" Wildcard is allowed, which blacklists all UUIDs except those in the whitelist. The blacklist is in effect only after being activated using activateBluetoothUUIDRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 // UUIDs to be removed from black list.
 List UUIDs = new ArrayList();
 UUIDs.add(BluetoothUUID.HSP_UUID);
 UUIDs.add(BluetoothUUID.HANDSFREE_UUID);
 try {
     boolean result = bluetoothPolicy.addBluetoothUUIDsToBlackList(UUIDs);
     if (true == result) {
         // UUID successfully added to blacklist
     } else {
         // UUID not added to blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. This API is used to add UUIDs to the Bluetooth UUID whitelist. Connections with matching UUIDs become exceptions from the blacklist. During specification, only the "*" Wild card is allowed, which whitelists all UUIDs. If the same UUID is present in the whitelist and blacklist and has been added by the same administrator, the whitelist takes preference. The whitelist takes effect only after being activated using activateBluetoothUUIDRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 // UUID to be removed from whitelist.
 List UUIDs = new ArrayList();
 UUIDs.add(BluetoothUUID.HSP_UUID);
 UUIDs.add(BluetoothUUID.HANDSFREE_UUID);
 try {
     boolean result = bluetoothPolicy.addBluetoothUUIDsToWhiteList(UUIDs);
     if (true == result) {
         // UUID successfully added to whitelist
     } else {
         // UUID not added to whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. An effectively can use this API to add UUIDs to the Bluetooth UUID whitelist. if defaultBlacklist is true, then by default all other UUID's are blacklisted. Connections with matching UUIDs become exceptions from the blacklist. During specification, only the "*" Wild card is allowed, which whitelists all UUIDs. If the same UUID is present in the whitelist and blacklist and has been added by the same administrator, the whitelist takes preference. The whitelist takes effect only after being activated using activateBluetoothUUIDRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 // UUID to be removed from whitelist.
 List UUIDs = new ArrayList();
 UUIDs.add(BluetoothUUID.HSP_UUID);
 UUIDs.add(BluetoothUUID.HANDSFREE_UUID);
 boolean defaultBlacklist = ture;
 try {
     boolean result = bluetoothPolicy.addBluetoothUUIDsToWhiteList(UUIDs, defaultBlacklist);
     if (true == result) {
         // UUID successfully added to whitelist
     } else {
         // UUID not added to whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();

 try {
     if (bluetoothPolicy.allowCallerIDDisplay(false)) {
         Log.d(TAG, "Caller Id display blocked successfully");
     } else {
         Log.d(TAG, "Failed to block caller Id display");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.allowOutgoingCalls(false);
     if (true == result) {
         // administered device cannot be connected to Bluetooth headset.
     } else {
         // default behaviour. Can be connected to a Bluetooth Headset if
         // not overridden previously.
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to remove all Bluetooth devices from the blacklist. The blacklist takes effect only after being activated using activateBluetoothDeviceRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.clearBluetoothDevicesFromBlackList();
     if (true == result) {
         // all devices cleared from blacklist
     } else {
         // devices not cleared from blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to remove all Bluetooth devices from the blacklist and whitelist. The blacklist and whitelist takes effect only after being activated using activateBluetoothDeviceRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.clearBluetoothDevicesFromList();
     if (true == result) {
         // all devices cleared from blacklist and whitelist
     } else {
         // devices not cleared from blacklist and whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to remove all Bluetooth devices from the whitelist. The whitelist takes effect only after being activated using activateBluetoothDeviceRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.clearBluetoothDevicesFromWhiteList();
     if (true == result) {
         // all devices cleared from the whitelist
     } else {
         // devices not cleared from the whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. This API removes all Bluetooth UUIDs from the blacklist for calling administrators. The blacklist is in effect only after being activated using activateBluetoothUUIDRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.clearBluetoothUUIDsFromBlackList();
     if (true == result) {
         // all UUIDs successfully cleared from blacklist
     } else {
         // all UUIDs not cleared from blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. This API removes all Bluetooth UUIDs from the blacklist and whitelist for calling administrators. The blacklist and whitelist is in effect only after being activated using activateBluetoothUUIDRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.clearBluetoothUUIDsFromList();
     if (true == result) {
         // all UUIDs successfully cleared from blacklist and whitelist
     } else {
         // all UUIDs not cleared from blacklist and whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. An administrator can use this API to remove all Bluetooth UUIDs from the whitelist. All exceptions due to the whitelist are removed for the same administrator. The whitelist takes effect only after being activated using activateBluetoothUUIDRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.clearBluetoothUUIDsFromWhiteList();
     if (true == result) {
         // all UUIDs cleared from whitelist
     } else {
         // all UUIDs not cleared from whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to get the list of blacklisted devices. Connections with matching devices are prevented.

An administrator can use this API to get the list of whitelisted devices for all administrators.

// Sample Output
1313632503413:[Device Visible]
Local Address: 43:34:B0:00:00:00
Local Name: GT-I9100

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. An administrator can use this API to get the list of UUIDs that are blacklisted by all administrators.

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. An administrator can use this API to get the list of whitelisted UUIDs. Connections with matching devices are allowed.

An administrator can use this API to check whether Bluetooth device restriction is active.

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. An administrator can check whether Bluetooth UUID restriction is active.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();

 try {
     if (bluetoothPolicy.isCallerIDDisplayAllowed()) {
         Log.d(TAG, "caller Id display allowed on call ");
     } else {
         Log.w(TAG, "caller Id display not allowed on call");
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to remove a Bluetooth device from the blacklist. Connections with matching devices are then allowed. The blacklist takes effect only after being activated using activateBluetoothDeviceRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 //device to be removed from black list.
 List devices = new ArrayList();
 devices.add("00:11:22:33:AA:BB");
 devices.add("00:11:22:88:AA:CC"};
 try {
     boolean result = bluetoothPolicy.removeBluetoothDevicesFromBlackList(devices);
     if (true == result) {
         //device successfully removed from blacklist
     } else {
         //device not removed from blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

An administrator can use this API to remove a Bluetooth device from the whitelist. The whitelist takes effect only after being activated using activateBluetoothDeviceRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 //device to be removed from white list.
 List devices = new ArrayList();
 devices.add("00:11:22:33:AA:BB");
 devices.add("00:11:22:88:AA:CC"};
 try {
     boolean result = bluetoothPolicy.removeBluetoothDevicesFromWhiteList(devices);
     if (true == result) {
         //device successfully removed from whitelist
     } else {
         //device not removed from whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. An administrator can use this API to remove Bluetooth UUIDs from the blacklist after they were added by addBluetoothUUIDsToBlackList(List). Connections with matching UUID are allowed after this API call. The blacklist is in effect only after being activated using activateBluetoothUUIDRestriction(boolean).

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 // UUIDs to be removed from black list.
 List UUIDs = new ArrayList();
 UUIDs.add(BluetoothUUID.HSP_UUID);
 UUIDs.add(BluetoothUUID.HANDSFREE_UUID);
 try {
     boolean result = bluetoothPolicy.removeBluetoothUUIDsFromBlackList(UUIDs);
     if (true == result) {
         // UUID removed successfully from blacklist
     } else {
         // UUID not removed from blacklist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

Bluetooth UUIDs represent features offered by devices and are used for interoperability between devices during communication. An administrator can use this API to remove Bluetooth UUIDs from the whitelist. Connections with matching UUID are allowed. If the same UUID is present in the whitelist and blacklist and was added by the same administrator, the whitelist takes preference. The whitelist takes effect only after being activated using activateBluetoothUUIDRestriction.

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 // UUID to be removed from whitelist.
 List UUIDs = new ArrayList();
 UUIDs.add(BluetoothUUID.HSP_UUID);
 UUIDs.add(BluetoothUUID.HANDSFREE_UUID);
 try {
     boolean result = bluetoothPolicy.removeBluetoothUUIDsFromWhiteList(UUIDs);
     if (true == result) {
         // UUID successfully removed from whitelist
     } else {
         // UUID not removed from whitelist
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.setAllowBluetoothDataTransfer(false);
     if (true == result) {
         // any file sharing through Bluetooth fails
     } else {
         // policy is not applied and previous state prevails
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }

 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.setBluetoothLogEnabled(true);
     if (true == result) {
         // log is enabled
     } else {
         // log is not enabled
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.setDesktopConnectivityState(false);
     if (true == result) {
         // administered device cannot be connected to any Bluetooth devices falling into
         // the desktop or laptop category
     } else {
         // default behaviour - can be connected to other Bluetooth devices
         // in a computer category if not overridden previously
         // with any other value.
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.setDiscoverableState(false);
     if (true == result) {
         // administered device cannot be discovered with any Bluetooth devices
     } else {
         // default behaviour - can be discovered by other Bluetooth devices
         // if not overridden previously with any other value.
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.setLimitedDiscoverableState(false);
     if (true == result) {
         // administered device can be always discovered.
     } else {
         // default behaviour - discoverable for 120 second if not overridden
         // previously with any other value.
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     boolean result = bluetoothPolicy.setPairingState(false);
     if (true == result) {
         // administrator device cannot be paired with any other Bluetooth devices.
     } else {
         // default behavior - can be paired with other Bluetooth devices, if not overridden
         // previously
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }
 

 EnterpriseDeviceManager edm = EnterpriseDeviceManager.getInstance(context);
 BluetoothPolicy bluetoothPolicy = edm.getBluetoothPolicy();
 try {
     // Block Bluetooth headset devices
     boolean result = bluetoothPolicy.setProfileState(false,
             BluetoothProfile.BLUETOOTH_HSP_PROFILE);
     if (true == result) {
         // administered device cannot be paired with any Bluetooth headset
         // devices
     } else {
         // default behaviour - can be paired with Bluetooth headset devices
         // if not overridden previously with any other value.
     }

     // Block Bluetooth hands-free devices connection
     result = bluetoothPolicy.setProfileState(false,
             BluetoothProfile.BLUETOOTH_HFP_PROFILE);
     if (true == result) {
         // administered device cannot be paired with any Bluetooth hands-free
         // devices
     } else {
         // default behaviour - can be paired with Bluetooth handsfree devices
         // if not overridden previously with any other value.
     }

     // Block Bluetooth A2DP supported devices connection
     result = bluetoothPolicy.setProfileState(false,
             BluetoothProfile.BLUETOOTH_A2DP_PROFILE);
     if (true == result) {
         // administered device cannot be paired with any Bluetooth a2dp
         // devices
     } else {
         // default behavior - can be paired with Bluetooth a2dp devices
         // if not overridden previously with any other value.
     }
 } catch (SecurityException e) {
     Log.w(TAG, "SecurityException: " + e);
 }