| /****************************************************************************** |
| * Copyright (c) 2020, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| *****************************************************************************/ |
| package com.android.settings.bluetooth; |
| |
| import androidx.preference.Preference; |
| import androidx.preference.PreferenceGroup; |
| import androidx.preference.PreferenceScreen; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.List; |
| |
| import com.android.settings.connecteddevice.ConnectedDeviceDashboardFragment; |
| import com.android.settings.widget.GearPreference.OnGearClickListener; |
| import com.android.settings.widget.GroupPreferenceCategory; |
| import com.android.settingslib.bluetooth.CachedBluetoothDevice; |
| import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager; |
| import com.android.settingslib.bluetooth.DeviceGroupClientProfile; |
| import com.android.settingslib.bluetooth.LocalBluetoothManager; |
| import com.android.settingslib.bluetooth.LocalBluetoothProfileManager; |
| import com.android.settingslib.bluetooth.LocalBluetoothProfile; |
| import com.android.settings.R; |
| |
| import com.android.settings.core.SubSettingLauncher; |
| import android.app.settings.SettingsEnums; |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.DeviceGroup; |
| import android.content.Context; |
| import android.os.SystemProperties; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.os.Bundle; |
| |
| /** |
| * GroupUtils is a helper class that contains various Group UI specific |
| * methods for add preference , remove preference, and group actions |
| */ |
| public class GroupUtils { |
| |
| public static final String TAG_GROUP = "Group"; |
| private static final String TAG = "GroupUtilss"; |
| private static final boolean D = ConnectedDeviceDashboardFragment.DBG_GROUP; |
| private static final boolean V = Log.isLoggable(TAG, Log.VERBOSE); |
| private Context mCtx; |
| private CachedBluetoothDeviceManager mCacheDeviceNamanger; |
| private DeviceGroupClientProfile mGroupClientProfile; |
| private DeviceGroup mDeviceGroup; |
| private static final int INVALID_SIZE = 0; |
| private static final int INVALID_GROUPID = -1; |
| public static final int GROUP_START_VAL = 1; |
| private static final String PROPERTY_GROUP = "persist.vendor.service.bt.adv_audio_mask"; |
| private boolean mIsGroupEnabled = false; |
| |
| protected LocalBluetoothProfileManager mProfileManager; |
| private LocalBluetoothManager mLocalBluetoothManager; |
| private LocalBluetoothProfile mBCProfile = null; |
| private static final String KEY_DEVICE_ADDRESS = "device_address"; |
| private static final String KEY_GROUP_OP = "group_op"; |
| /* |
| * Returns whether if the device is group device. |
| */ |
| boolean isGroupDevice(CachedBluetoothDevice cachedDevice) { |
| if (!mIsGroupEnabled) { |
| if (D) { |
| loge(" GroupProfile not enabled"); |
| } |
| return false; |
| } |
| if (!cachedDevice.isGroupDevice()) { |
| if (cachedDevice.isTypeUnKnown()) { |
| int type = cachedDevice.getDevice().getDeviceType(); |
| updateGroupStatus(cachedDevice, type); |
| } |
| } |
| if (D) { |
| Log.d(TAG, "isGroupDevice " + cachedDevice.isGroupDevice() + cachedDevice |
| + " name " + cachedDevice.getName() + " type " + cachedDevice.getmType()); |
| } |
| return cachedDevice.isGroupDevice(); |
| } |
| |
| String getGroupTitle(int groupId) { |
| return " " + (groupId + GROUP_START_VAL); |
| } |
| |
| /* |
| * Get group id associated with this device |
| */ |
| int getGroupId(CachedBluetoothDevice device) { |
| int groupId = device.getGroupId(); |
| if (groupId == -1) { |
| loge(" groupId is -1"); |
| } |
| if (D) { |
| Log.d(TAG, "getgroupId " + groupId + " device " + device); |
| } |
| return groupId; |
| } |
| |
| private void updateGroupStatus(CachedBluetoothDevice device, int groupId) { |
| device.setDeviceType(groupId); |
| CachedBluetoothDevice cacheDevice = mCacheDeviceNamanger.findDevice(device.getDevice()); |
| if (cacheDevice != null) { |
| cacheDevice.setDeviceType(groupId); |
| if (D) { |
| Log.d(TAG, "updateGroupStatus updated " + device + " " + groupId); |
| } |
| } else { |
| loge("updateGroupStatus failed " + device + " groupId " + groupId); |
| } |
| } |
| |
| public GroupUtils(Context ctx) { |
| mCtx = ctx; |
| mCacheDeviceNamanger = Utils.getLocalBtManager(mCtx).getCachedDeviceManager(); |
| isGroupEnabled(); |
| mLocalBluetoothManager = Utils.getLocalBtManager(mCtx); |
| if (mLocalBluetoothManager == null) { |
| Log.e(TAG, "Bluetooth is not supported on this device"); |
| return; |
| } |
| mProfileManager = mLocalBluetoothManager.getProfileManager(); |
| mBCProfile = mProfileManager.getBCProfile(); |
| } |
| |
| private int getGroupId(Preference preference) { |
| CachedBluetoothDevice dev = null; |
| int groupId = -1; |
| if (preference instanceof BluetoothDevicePreference) { |
| dev = ((BluetoothDevicePreference) preference).getBluetoothDevice(); |
| groupId = getGroupId(dev); |
| } |
| if (groupId == -1) { |
| loge("group id not found " + dev.getAddress()); |
| } |
| return groupId; |
| } |
| |
| private boolean isNewGroup(int id, ArrayList< GroupPreferenceCategory> groupList) { |
| boolean isNew = true; |
| for (int i = 0; i< groupList.size() - 1; i++) { |
| GroupPreferenceCategory tempGroup = groupList.get(i); |
| if (tempGroup == null) { |
| loge("isNewGroup tempGroup null"); |
| return false; |
| } |
| int val = tempGroup.getGroupId(); |
| if (D) { |
| Log.d(TAG, "isNewGroup val " + val + " key " + tempGroup.getKey()); |
| } |
| if (id == val) { |
| isNew = false; |
| break; |
| } |
| } |
| if (D) { |
| Log.d(TAG, "isNewGroup id " + id + " val " + isNew); |
| } |
| return isNew; |
| } |
| |
| private boolean isAllFilled(int id, ArrayList< GroupPreferenceCategory> groupList) { |
| boolean filled = true; |
| for (int i = 0; i< groupList.size() - 1; i++) { |
| GroupPreferenceCategory tempGroup = groupList.get(i); |
| if (tempGroup == null) { |
| loge("isAllFilled"); |
| return false; |
| } |
| int val = tempGroup.getGroupId(); |
| if (id == val) { |
| filled = false; |
| break; |
| } |
| } |
| return filled; |
| } |
| |
| |
| private GroupPreferenceCategory getParentGroup(ArrayList< GroupPreferenceCategory> groupList, |
| Preference preference) { |
| GroupPreferenceCategory group = null; |
| for (int i = 0; i< groupList.size() - 1; i++) { |
| GroupPreferenceCategory tempGroup = groupList.get(i); |
| if (tempGroup.getPreferenceCount() == 0) { |
| group = tempGroup; |
| break; |
| } |
| } |
| return group; |
| } |
| |
| private GroupPreferenceCategory getExistingGroup(ArrayList< GroupPreferenceCategory> mGroupList, |
| Preference preference) { |
| GroupPreferenceCategory group = null; |
| int groupId = getGroupId(preference); |
| for (GroupPreferenceCategory tempGroup : mGroupList) { |
| int val = tempGroup.getGroupId(); |
| if (groupId == val) { |
| group = tempGroup; |
| break; |
| } |
| } |
| return group; |
| } |
| |
| private GroupBluetoothSettingsPreference getHedaer(int groupId, |
| OnGearClickListener listener ) { |
| GroupBluetoothSettingsPreference headerPreference = |
| new GroupBluetoothSettingsPreference(mCtx, groupId); |
| headerPreference.setOnGearClickListener(listener); |
| return headerPreference; |
| } |
| |
| /* |
| * Add preference based on below conditions |
| * a) Get group id based on Preference |
| * b) Check if already group header is present or not |
| * c) If new group create header |
| * d) Get available GroupPreferenceCategory instance |
| * e) Add Header and preference |
| * f) If group already present get group based on id |
| * g) Add preference to existing header |
| */ |
| public void addPreference(ArrayList< GroupPreferenceCategory> listCategories, |
| Preference preference, OnGearClickListener listener) { |
| int groupId = getGroupId(preference); |
| if (groupId == -1) { |
| loge("addPreference groupId is not valid "+ groupId); |
| return; |
| } |
| boolean isNewGroup = isNewGroup(groupId, listCategories); |
| if (D) { |
| Log.d(TAG, "addPreference " + preference + " isNewGroup " + isNewGroup); |
| } |
| String key ; |
| GroupPreferenceCategory group = null; |
| if (isNewGroup) { |
| GroupBluetoothSettingsPreference header = getHedaer(groupId, listener); |
| group = getParentGroup(listCategories, preference); |
| if (group == null) { |
| loge("getParentGroup not found for groupId " + groupId); |
| isAllGroupsFilled(listCategories, header); |
| return; |
| } |
| group.setGroupId(groupId); |
| group.addPreference(header); |
| group.addPreference(preference); |
| group.setVisible(true); |
| } else { |
| group = getExistingGroup(listCategories, preference); |
| if (group == null) { |
| loge("getExistingGroup not found for groupId " + groupId); |
| return; |
| } |
| group.addPreference(preference); |
| } |
| if (D) { |
| Log.d(TAG , "addPreference key " + group.getKey()); |
| } |
| } |
| |
| /* |
| * Remove preference based on below conditions |
| * a) Get existing Preference Category |
| * b) Remove preference from category |
| * c) If preference count is one remove header |
| */ |
| public void removePreference(ArrayList< GroupPreferenceCategory> listCategories, |
| Preference preference) { |
| GroupPreferenceCategory group = getExistingGroup(listCategories, preference); |
| if (group == null) { |
| loge("removePreference group null "); |
| removePreference(listCategories.get(listCategories.size()-1), preference); |
| return; |
| } |
| group.removePreference(preference); |
| if (group.getPreferenceCount() == 1) { |
| group.setGroupId(INVALID_GROUPID); |
| group.removeAll(); |
| group.setVisible(false); |
| } |
| } |
| |
| /* |
| * Remove Header if child count is 0 |
| */ |
| private void removePreference(GroupPreferenceCategory groupCategory, |
| Preference preference) { |
| int size = groupCategory.getPreferenceCount(); |
| if (size == 0) { |
| loge("removePreference Header invalid"); |
| return; |
| } |
| int groupId = getGroupId(preference); |
| if (groupId == INVALID_GROUPID) { |
| loge("removePreference Header groupId is invalid"); |
| return; |
| } |
| for (int i=0;i<size; i++) { |
| GroupBluetoothSettingsPreference headerPreference = |
| (GroupBluetoothSettingsPreference) groupCategory.getPreference(i); |
| if (D) { |
| Log.d(TAG, "removePreference Header headerPreference " |
| + headerPreference + " header id " |
| + headerPreference.getGroupId() + " groupId " + groupId ); |
| } |
| if (headerPreference.getGroupId() == groupId) { |
| int chCount = headerPreference.decrementChildCount(); |
| if (D) { |
| Log.d(TAG,"removePreference Header group id chCount " + chCount ); |
| } |
| if (chCount <= 0) { |
| groupCategory.removePreference(headerPreference); |
| } |
| } |
| } |
| } |
| |
| /* |
| * If more than nine groups add headers only |
| */ |
| private void isAllGroupsFilled(ArrayList<GroupPreferenceCategory> listCategories, |
| GroupBluetoothSettingsPreference preference) { |
| boolean isFilled = isAllFilled(-1, listCategories); |
| GroupPreferenceCategory group = listCategories.get(listCategories.size() - 1); |
| if (isFilled) { |
| if (group == null) { |
| loge("isAllGroupsFilled received invalid group"); |
| return; |
| } |
| if (!group.getKey().contains("remaining")) { |
| loge("isAllGroupsFilled not last group"); |
| return; |
| } |
| int size = group.getPreferenceCount(); |
| if (D) { |
| Log.d(TAG, "isAllGroupsFilled size " + size); |
| } |
| boolean found = false; |
| for (int i = 0; i < size; i++) { |
| if (group.getPreference(i) instanceof GroupBluetoothSettingsPreference) { |
| GroupBluetoothSettingsPreference pref = |
| (GroupBluetoothSettingsPreference )group.getPreference(i); |
| if (preference.getGroupId() == pref.getGroupId()) { |
| found = true; |
| int chCount = pref.incrementChildCound(); |
| if(D) { |
| Log.d(TAG, "isAllGroupsFilled updated chCount " + chCount); |
| } |
| break; |
| } |
| } |
| } |
| if (!found) { |
| int chCount = preference.incrementChildCound(); |
| group.addPreference(preference); |
| if (D) { |
| Log.d(TAG, "isAllGroupsFilled added chCount " + chCount); |
| } |
| } |
| } |
| } |
| |
| ArrayList<CachedBluetoothDevice> getCahcedDevice(int groupId) { |
| Collection<CachedBluetoothDevice> cachedDevices = |
| mCacheDeviceNamanger.getCachedDevicesCopy(); |
| ArrayList<CachedBluetoothDevice> list = new ArrayList<CachedBluetoothDevice>(); |
| for (CachedBluetoothDevice cachedDevice : cachedDevices) { |
| if (cachedDevice != null && isGroupDeviceBonded(cachedDevice) |
| && getGroupId(cachedDevice) == groupId) { |
| list.add(cachedDevice); |
| } |
| } |
| if (D) { |
| Log.d(TAG, "getCahcedDevice " + groupId + " list " + list + " " + list.size()); |
| } |
| return list; |
| } |
| |
| public BluetoothDevice getAnyBCConnectedDevice (int groupId) { |
| BluetoothDevice bcMemberDevice = null; |
| |
| mDeviceGroup = mGroupClientProfile.getGroup(groupId); |
| if (mDeviceGroup == null) { |
| Log.e(TAG, "getAnyBCConnectedDevice: dGrp is null"); |
| return null; |
| } |
| if (mBCProfile == null) { |
| Log.e(TAG, "getAnyBCConnectedDevice: BCProfile is null"); |
| return null; |
| } |
| List<BluetoothDevice> setMembers = mDeviceGroup.getDeviceGroupMembers(); |
| for (BluetoothDevice dev : setMembers) { |
| if (mBCProfile.getConnectionStatus(dev) == BluetoothProfile.STATE_CONNECTED) { |
| bcMemberDevice = dev; |
| break; |
| } |
| } |
| return bcMemberDevice; |
| } |
| void launchAddSourceGroup(int groupId) { |
| Class<?> SADetail = null; |
| try { |
| SADetail = Class.forName("com.android.settings.bluetooth.BluetoothSADetail"); |
| } catch (ClassNotFoundException ex) { |
| Log.e(TAG, "no SADetail exists"); |
| SADetail = null; |
| } |
| if (SADetail != null) { |
| BluetoothDevice bcMemberDevice = getAnyBCConnectedDevice(groupId); |
| final Bundle args = new Bundle(); |
| if (bcMemberDevice == null) { |
| //do nothing |
| return; |
| } |
| args.putString(KEY_DEVICE_ADDRESS, |
| bcMemberDevice.getAddress()); |
| args.putShort(KEY_GROUP_OP, |
| (short)1); |
| |
| new SubSettingLauncher(mCtx) |
| .setDestination("com.android.settings.bluetooth.BluetoothSADetail") |
| .setArguments(args) |
| .setTitleRes(R.string.bluetooth_search_broadcasters) |
| .setSourceMetricsCategory(SettingsEnums.BLUETOOTH_DEVICE_PICKER) |
| .launch(); |
| } |
| return; |
| } |
| |
| boolean connectGroup(int groupId) { |
| if (isValid()) { |
| return mGroupClientProfile.connectGroup(groupId); |
| } |
| return false; |
| } |
| |
| boolean disconnectGroup(int groupId) { |
| if (isValid()) { |
| return mGroupClientProfile.disconnectGroup(groupId); |
| } |
| return false; |
| } |
| |
| boolean forgetGroup(int groupId) { |
| if (isValid()) { |
| return mGroupClientProfile.forgetGroup(groupId); |
| } |
| return false; |
| } |
| |
| boolean isGroupDiscoveryInProgress(int groupId) { |
| if (!isValid()) { |
| return false; |
| } |
| return mGroupClientProfile.isGroupDiscoveryInProgress(groupId); |
| } |
| |
| boolean startGroupDiscovery(int groupId) { |
| if (!isValid()) { |
| return false; |
| } |
| boolean isDiscovering= mGroupClientProfile.isGroupDiscoveryInProgress(groupId); |
| if (D) { |
| Log.d(TAG, "startGroupDiscovery " + groupId + "isDiscovering " + isDiscovering); |
| } |
| if (!isDiscovering) { |
| mGroupClientProfile.startGroupDiscovery(groupId); |
| return true; |
| } |
| return false; |
| } |
| |
| boolean stopGroupDiscovery(int groupId) { |
| if (!isValid()) { |
| return false; |
| } |
| boolean isDiscovering = mGroupClientProfile.isGroupDiscoveryInProgress(groupId); |
| if (D) { |
| Log.d(TAG, "stopGroupDiscovery " + groupId + "isDiscovering " + isDiscovering); |
| } |
| if (isDiscovering) { |
| mGroupClientProfile.stopGroupDiscovery(groupId); |
| return true; |
| } |
| return false; |
| } |
| |
| int getGroupSize(int groupId) { |
| int size = INVALID_SIZE; |
| if (isValid()) { |
| mDeviceGroup = mGroupClientProfile.getGroup(groupId); |
| if (mDeviceGroup != null) { |
| size = mDeviceGroup.getDeviceGroupSize(); |
| } |
| } |
| if (D) { |
| Log.d(TAG, "getDeviceGroupSize size " + size); |
| } |
| return size; |
| } |
| |
| public boolean isHidePCGGroups() { |
| boolean isHide = true; |
| List<BluetoothDevice> bluetoothDevices = |
| BluetoothAdapter.getDefaultAdapter().getMostRecentlyConnectedDevices(); |
| if (bluetoothDevices != null && bluetoothDevices.size() > 0) { |
| for (BluetoothDevice device : bluetoothDevices) { |
| CachedBluetoothDevice cachedDevice = mCacheDeviceNamanger.findDevice(device); |
| if (cachedDevice != null && isGroupDeviceBondedOnly(cachedDevice)) { |
| isHide = false; |
| break; |
| } |
| } |
| } |
| if (D) { |
| Log.d(TAG, "isHidePCGGroups " + isHide); |
| } |
| return isHide; |
| } |
| |
| boolean isHideGroupOptions(int groupId) { |
| boolean isHide = true; |
| Collection<CachedBluetoothDevice> cachedDevices = |
| mCacheDeviceNamanger.getCachedDevicesCopy(); |
| if (cachedDevices != null && cachedDevices.size() > 0) { |
| for (CachedBluetoothDevice cachedDevice : cachedDevices) { |
| if (cachedDevice != null && isGroupDeviceBonded(cachedDevice) |
| && isGroupIdMatch(cachedDevice, groupId)) { |
| isHide = false; |
| break; |
| } |
| } |
| } |
| if (D) { |
| Log.d(TAG, "isHideGroupOptions " + isHide); |
| } |
| return isHide; |
| } |
| |
| private boolean isGroupDeviceBondedOnly(CachedBluetoothDevice cachedDevice) { |
| if (cachedDevice.getBondState() == BluetoothDevice.BOND_BONDED |
| && !cachedDevice.isConnected() && isGroupDevice(cachedDevice)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| private boolean isGroupIdMatch(CachedBluetoothDevice cachedDevice, int groupId) { |
| return groupId == getGroupId(cachedDevice); |
| } |
| |
| private boolean isGroupDeviceBonded(CachedBluetoothDevice cachedDevice) { |
| if (cachedDevice.getBondState() == BluetoothDevice.BOND_BONDED |
| && isGroupDevice(cachedDevice)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| private void loge(String msg) { |
| Log.e(TAG, msg); |
| } |
| |
| private boolean isValid() { |
| if (mGroupClientProfile == null) { |
| LocalBluetoothProfileManager profilemanager = |
| Utils.getLocalBtManager(mCtx).getProfileManager(); |
| mGroupClientProfile = profilemanager.getDeviceGroupClientProfile(); |
| } |
| return (mGroupClientProfile == null) ? false : true; |
| } |
| |
| private void isGroupEnabled() { |
| try { |
| int advAudioFeatureMask = SystemProperties.getInt(PROPERTY_GROUP, 0); |
| if (D) { |
| Log.d(TAG,"isGroupEnabled advAudioFeatureMask " + advAudioFeatureMask); |
| } |
| if (advAudioFeatureMask != 0) { |
| mIsGroupEnabled = true; |
| } |
| } catch (Exception e) { |
| mIsGroupEnabled = false; |
| Log.e(TAG, "isGroupEnabled " + e); |
| } |
| } |
| |
| boolean isUpdate(int groupId, CachedBluetoothDevice cachedDevice) { |
| return (isGroupDevice(cachedDevice) && groupId == getGroupId(cachedDevice)); |
| } |
| |
| boolean addDevice(ArrayList<CachedBluetoothDevice> deviceList, int groupId, |
| CachedBluetoothDevice cachedDevice) { |
| boolean add = true; |
| boolean isAdded = false; |
| if (isUpdate(groupId, cachedDevice)) { |
| for (CachedBluetoothDevice device : deviceList) { |
| if (device.getAddress().equals(cachedDevice.getAddress())) { |
| add = false; |
| break; |
| } |
| } |
| if (add) { |
| isAdded = deviceList.add(cachedDevice); |
| } |
| } |
| if (D) { |
| Log.d(TAG, "addDevice cachedDevice " + cachedDevice + " name " + |
| cachedDevice.getName() + " is added " + isAdded); |
| } |
| return add; |
| } |
| |
| boolean removeDevice(ArrayList<CachedBluetoothDevice> deviceList, int groupId, |
| CachedBluetoothDevice cachedDevice) { |
| boolean remove = false; |
| boolean isremoved = false; |
| CachedBluetoothDevice removedDevice = null ; |
| if (isUpdate(groupId, cachedDevice)) { |
| for (CachedBluetoothDevice device : deviceList) { |
| if (device.getAddress().equals(cachedDevice.getAddress())) { |
| remove = true; |
| removedDevice = device; |
| break; |
| } |
| } |
| if (remove) { |
| isremoved = deviceList.remove(removedDevice); |
| } |
| } |
| if (D) { |
| Log.d(TAG, "removeDevice cachedDevice " + cachedDevice + " name " + |
| cachedDevice.getName() + " isremoved " + isremoved); |
| } |
| return remove; |
| } |
| } |