MarcoBuster/Gadgetbridge
1
0
Fork 0
mirror of https://codeberg.org/Freeyourgadget/Gadgetbridge synced 2024-11-29 05:16:51 +01:00
Code Releases Wiki Activity

Remove scanning intensity preference and legacy discovery activity

Browse Source 
The refactored DiscoveryActivityV2 does not freeze anymore, even under
maximum scanning intensity on older phones, and seems to not have
introduced any regressions.
This commit is contained in:
José Rebelo 2023-10-06 22:16:58 +01:00
parent fe9b88df17
commit dcf2629854
11 changed files with 8 additions and 1071 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/src/main/AndroidManifest.xml
View File

@ -546,10 +546,6 @@
android:label="@string/title_activity_notification_management"
android:parentActivityName=".activities.ControlCenterv2"
android:windowSoftInputMode="stateHidden" />
<activity
android:name=".activities.discovery.DiscoveryActivity"
android:label="@string/title_activity_discovery"
android:parentActivityName=".activities.ControlCenterv2" />
<activity
android:name=".activities.discovery.DiscoveryActivityV2"
android:label="@string/title_activity_discovery"

4
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/GBApplication.java
View File

@ -1401,10 +1401,6 @@ public class GBApplication extends Application {
return prefs;
}
public static boolean useNewDiscoveryActivity() {
return prefs.getBoolean("new_discover_activity", true);
}
public static GBPrefs getGBPrefs() {
return gbPrefs;
}

5
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/activities/ControlCenterv2.java
View File

@ -84,7 +84,6 @@ import java.util.Set;
import nodomain.freeyourgadget.gadgetbridge.BuildConfig;
import nodomain.freeyourgadget.gadgetbridge.GBApplication;
import nodomain.freeyourgadget.gadgetbridge.R;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivityV2;
import nodomain.freeyourgadget.gadgetbridge.adapter.GBDeviceAdapterv2;
import nodomain.freeyourgadget.gadgetbridge.database.DBAccess;
@ -483,11 +482,7 @@ public class ControlCenterv2 extends AppCompatActivity
}
private void launchDiscoveryActivity() {
if (GBApplication.useNewDiscoveryActivity()) {
startActivity(new Intent(this, DiscoveryActivityV2.class));
} else {
startActivity(new Intent(this, DiscoveryActivity.class));
}
}
private void refreshPairedDevices() {

981
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/activities/discovery/DiscoveryActivity.java
View File

@ -1,981 +0,0 @@
/* Copyright (C) 2015-2020 Andreas Shimokawa, boun, Carsten Pfeiffer, Daniel
Dakhno, Daniele Gobbetti, JohnnySun, jonnsoft, Lem Dulfo, Taavi Eomäe,
Uwe Hermann
This file is part of Gadgetbridge.
Gadgetbridge is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Gadgetbridge is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
package nodomain.freeyourgadget.gadgetbridge.activities.discovery;
import static nodomain.freeyourgadget.gadgetbridge.util.GB.toast;
import android.Manifest;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.le.BluetoothLeScanner;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.le.ScanFilter;
import android.bluetooth.le.ScanRecord;
import android.bluetooth.le.ScanResult;
import android.bluetooth.le.ScanSettings;
import android.content.BroadcastReceiver;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.location.LocationManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelUuid;
import android.os.Parcelable;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.Pair;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.Spinner;
import android.widget.Toast;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.core.app.ActivityCompat;
import com.google.android.material.dialog.MaterialAlertDialogBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import nodomain.freeyourgadget.gadgetbridge.GBApplication;
import nodomain.freeyourgadget.gadgetbridge.R;
import nodomain.freeyourgadget.gadgetbridge.activities.AbstractGBActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.DebugActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.devicesettings.DeviceSettingsActivity;
import nodomain.freeyourgadget.gadgetbridge.adapter.DeviceCandidateAdapter;
import nodomain.freeyourgadget.gadgetbridge.adapter.SpinnerWithIconAdapter;
import nodomain.freeyourgadget.gadgetbridge.adapter.SpinnerWithIconItem;
import nodomain.freeyourgadget.gadgetbridge.devices.DeviceCoordinator;
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
import nodomain.freeyourgadget.gadgetbridge.impl.GBDeviceCandidate;
import nodomain.freeyourgadget.gadgetbridge.model.DeviceType;
import nodomain.freeyourgadget.gadgetbridge.util.AndroidUtils;
import nodomain.freeyourgadget.gadgetbridge.util.BondingInterface;
import nodomain.freeyourgadget.gadgetbridge.util.BondingUtil;
import nodomain.freeyourgadget.gadgetbridge.util.DeviceHelper;
import nodomain.freeyourgadget.gadgetbridge.util.GB;
import nodomain.freeyourgadget.gadgetbridge.util.Prefs;
@Deprecated // use DiscoveryActivityV2, this is just kept in case of bugs
public class DiscoveryActivity extends AbstractGBActivity implements AdapterView.OnItemClickListener, AdapterView.OnItemLongClickListener, BondingInterface {
private static final Logger LOG = LoggerFactory.getLogger(DiscoveryActivity.class);
private static final long SCAN_DURATION = 30000; // 30s
private final Handler handler = new Handler();
private final ArrayList<GBDeviceCandidate> deviceCandidates = new ArrayList<>();
int CallbackType = android.bluetooth.le.ScanSettings.CALLBACK_TYPE_ALL_MATCHES;
int MatchMode = android.bluetooth.le.ScanSettings.MATCH_MODE_STICKY;
private ScanCallback newBLEScanCallback = null;
/**
* If already bonded devices are to be ignored when scanning
*/
private boolean ignoreBonded = true;
private boolean discoverUnsupported = false;
private ProgressBar bluetoothProgress;
private ProgressBar bluetoothLEProgress;
private DeviceCandidateAdapter deviceCandidateAdapter;
private GBDeviceCandidate deviceTarget;
private BluetoothAdapter adapter;
private BluetoothLeScanner bluetoothLeScanner;
private Button startButton;
private boolean scanning;
private long selectedUnsupportedDeviceKey = DebugActivity.SELECT_DEVICE;
private final Runnable stopRunnable = new Runnable() {
@Override
public void run() {
stopDiscovery();
LOG.info("Discovery stopped by thread timeout.");
}
};
private Set<BTUUIDPair> foundCandidates = new HashSet<>();
private final BroadcastReceiver bluetoothReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
switch (Objects.requireNonNull(intent.getAction())) {
case BluetoothAdapter.ACTION_DISCOVERY_STARTED: {
LOG.debug("ACTION_DISCOVERY_STARTED");
break;
}
case BluetoothAdapter.ACTION_STATE_CHANGED: {
LOG.debug("ACTION_STATE_CHANGED ");
bluetoothStateChanged(intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.STATE_OFF));
break;
}
case BluetoothDevice.ACTION_FOUND: {
LOG.debug("ACTION_FOUND");
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
handleDeviceFound(device, intent.getShortExtra(BluetoothDevice.EXTRA_RSSI, GBDevice.RSSI_UNKNOWN));
break;
}
case BluetoothDevice.ACTION_UUID: {
LOG.debug("ACTION_UUID");
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
short rssi = intent.getShortExtra(BluetoothDevice.EXTRA_RSSI, GBDevice.RSSI_UNKNOWN);
Parcelable[] uuids = intent.getParcelableArrayExtra(BluetoothDevice.EXTRA_UUID);
ParcelUuid[] uuids2 = AndroidUtils.toParcelUuids(uuids);
addToCandidateListIfNotAlreadyProcessed(device, rssi, uuids2);
break;
}
case BluetoothDevice.ACTION_BOND_STATE_CHANGED: {
LOG.debug("ACTION_BOND_STATE_CHANGED");
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
if (device != null) {
int bondState = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.BOND_NONE);
LOG.debug(String.format(Locale.ENGLISH, "Bond state: %d", bondState));
if (bondState == BluetoothDevice.BOND_BONDED) {
BondingUtil.handleDeviceBonded((BondingInterface) context, getCandidateFromMAC(device));
}
}
break;
}
}
}
};
public void logMessageContent(byte[] value) {
if (value != null) {
LOG.warn("DATA: " + GB.hexdump(value, 0, value.length));
}
}
@RequiresApi(Build.VERSION_CODES.O)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
BondingUtil.handleActivityResult(this, requestCode, resultCode, data);
}
private GBDeviceCandidate getCandidateFromMAC(BluetoothDevice device) {
for (GBDeviceCandidate candidate : deviceCandidates) {
if (candidate.getMacAddress().equals(device.getAddress())) {
return candidate;
}
}
LOG.warn(String.format("This shouldn't happen unless the list somehow emptied itself, device MAC: %1$s", device.getAddress()));
return null;
}
private ScanCallback getScanCallback() {
if (newBLEScanCallback != null) {
return newBLEScanCallback;
}
newBLEScanCallback = new ScanCallback() {
@Override
public void onScanResult(int callbackType, ScanResult result) {
super.onScanResult(callbackType, result);
try {
ScanRecord scanRecord = result.getScanRecord();
ParcelUuid[] uuids = null;
if (scanRecord != null) {
//logMessageContent(scanRecord.getBytes());
List<ParcelUuid> serviceUuids = scanRecord.getServiceUuids();
if (serviceUuids != null) {
uuids = serviceUuids.toArray(new ParcelUuid[0]);
}
}
String name = "[unknown]";
try {
name = result.getDevice().getName();
} catch (SecurityException e) {
/* This should never happen because we need all the permissions
to get to the point where we can even scan, but 'SecurityException' check
is added to stop Android Studio errors */
LOG.error("SecurityException on device.getName()");
}
LOG.warn(name + ": " +
((scanRecord != null) ? scanRecord.getBytes().length : -1));
addToCandidateListIfNotAlreadyProcessed(result.getDevice(), (short) result.getRssi(), uuids);
} catch (NullPointerException e) {
LOG.warn("Error handling scan result", e);
}
}
};
return newBLEScanCallback;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
loadSettingsValues();
setContentView(R.layout.activity_discovery);
startButton = findViewById(R.id.discovery_start);
startButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
onStartButtonClick(startButton);
}
});
Button settingsButton = findViewById(R.id.discovery_preferences);
settingsButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent enableIntent = new Intent(DiscoveryActivity.this, DiscoveryPairingPreferenceActivity.class);
startActivity(enableIntent);
}
});
bluetoothProgress = findViewById(R.id.discovery_progressbar);
bluetoothProgress.setProgress(0);
bluetoothProgress.setIndeterminate(true);
bluetoothProgress.setVisibility(View.GONE);
ListView deviceCandidatesView = findViewById(R.id.discovery_device_candidates_list);
bluetoothLEProgress = findViewById(R.id.discovery_ble_progressbar);
bluetoothLEProgress.setProgress(0);
bluetoothLEProgress.setIndeterminate(true);
bluetoothLEProgress.setVisibility(View.GONE);
deviceCandidateAdapter = new DeviceCandidateAdapter(this, deviceCandidates);
deviceCandidatesView.setAdapter(deviceCandidateAdapter);
deviceCandidatesView.setOnItemClickListener(this);
deviceCandidatesView.setOnItemLongClickListener(this);
registerBroadcastReceivers();
checkAndRequestLocationPermission();
if (!startDiscovery()) {
/* if we couldn't start scanning, go back to the main page.
A toast will have been shown explaining what's wrong */
finish();
}
}
public void onStartButtonClick(View button) {
LOG.debug("Start button clicked");
if (isScanning()) {
stopDiscovery();
} else {
deviceCandidates.clear();
deviceCandidateAdapter.notifyDataSetChanged();
startDiscovery();
}
}
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
super.onSaveInstanceState(outState);
outState.putParcelableArrayList("deviceCandidates", deviceCandidates);
}
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
ArrayList<Parcelable> restoredCandidates = savedInstanceState.getParcelableArrayList("deviceCandidates");
if (restoredCandidates != null) {
deviceCandidates.clear();
for (Parcelable p : restoredCandidates) {
deviceCandidates.add((GBDeviceCandidate) p);
}
}
}
@Override
protected void onDestroy() {
unregisterBroadcastReceivers();
stopDiscovery();
super.onDestroy();
}
@Override
protected void onStop() {
unregisterBroadcastReceivers();
stopDiscovery();
super.onStop();
}
@Override
protected void onPause() {
unregisterBroadcastReceivers();
stopDiscovery();
super.onPause();
}
@Override
protected void onResume() {
loadSettingsValues();
registerBroadcastReceivers();
super.onResume();
}
private void handleDeviceFound(BluetoothDevice device, short rssi) throws SecurityException {
if (device.getName() != null) {
if (handleDeviceFound(device, rssi, null)) {
LOG.info("found supported device " + device.getName() + " without scanning services, skipping service scan.");
return;
}
}
ParcelUuid[] uuids = device.getUuids();
if (uuids == null) {
if (device.fetchUuidsWithSdp()) {
return;
}
}
addToCandidateListIfNotAlreadyProcessed(device, rssi, uuids);
}
private void addToCandidateListIfNotAlreadyProcessed(BluetoothDevice device, short rssi, ParcelUuid[] uuids) {
BTUUIDPair btuuidPair = new BTUUIDPair(device, uuids);
if (foundCandidates.contains(btuuidPair)) {
// LOG.info("candidate already processed, skipping");
return;
}
if (handleDeviceFound(device, rssi, uuids)) {
//device was considered a candidate, do not process it again unless something changed
foundCandidates.add(btuuidPair);
}
}
private boolean handleDeviceFound(BluetoothDevice device, short rssi, ParcelUuid[] uuids) throws SecurityException {
LOG.debug("found device: " + device.getName() + ", " + device.getAddress());
if (LOG.isDebugEnabled()) {
if (uuids != null && uuids.length > 0) {
for (ParcelUuid uuid : uuids) {
LOG.debug(" supports uuid: " + uuid.toString());
}
}
}
boolean bonded = false;
try {
bonded = device.getBondState() == BluetoothDevice.BOND_BONDED;
} catch (SecurityException e) {
/* This should never happen because we need all the permissions
to get to the point where we can even scan, but 'SecurityException' check
is added to stop Android Studio errors */
LOG.error("SecurityException on device.getBondState");
}
if (bonded && ignoreBonded) {
return true; // Ignore already bonded devices
}
GBDeviceCandidate candidate = new GBDeviceCandidate(device, rssi, uuids);
candidate.refreshNameIfUnknown();
candidate.addUuids(device.getUuids());
DeviceType deviceType = DeviceHelper.getInstance().resolveDeviceType(candidate);
if (deviceType.isSupported() || discoverUnsupported) {
candidate.setDeviceType(deviceType);
LOG.info("Recognized device: " + candidate);
int index = deviceCandidates.indexOf(candidate);
if (index >= 0) {
deviceCandidates.set(index, candidate); // replace
} else {
deviceCandidates.add(candidate);
}
deviceCandidateAdapter.notifyDataSetChanged();
return true;
}
return false;
}
private boolean startDiscovery() {
if (isScanning()) {
LOG.warn("Not starting discovery, because already scanning.");
return false;
}
LOG.info("Starting discovery");
startButton.setText(getString(R.string.discovery_stop_scanning));
if (ensureBluetoothReady()) {
if (GB.supportsBluetoothLE()) {
startBTLEDiscovery();
startBTDiscovery();
} else {
startBTDiscovery();
}
setScanning(true);
} else {
toast(DiscoveryActivity.this, getString(R.string.discovery_enable_bluetooth), Toast.LENGTH_SHORT, GB.ERROR);
return false;
}
return true;
}
private void stopDiscovery() {
LOG.info("Stopping discovery");
stopBTDiscovery();
stopBLEDiscovery();
setScanning(false);
handler.removeMessages(0, stopRunnable);
}
private boolean isScanning() {
return scanning;
}
public void setScanning(boolean scanning) {
this.scanning = scanning;
if (scanning) {
startButton.setText(getString(R.string.discovery_stop_scanning));
} else {
startButton.setText(getString(R.string.discovery_start_scanning));
bluetoothProgress.setVisibility(View.GONE);
bluetoothLEProgress.setVisibility(View.GONE);
}
}
private void startBTLEDiscovery() {
LOG.info("Starting BLE discovery");
handler.removeMessages(0, stopRunnable);
handler.sendMessageDelayed(getPostMessage(stopRunnable), SCAN_DURATION);
// Filters being non-null would be a very good idea with background scan, but in this case,
// not really required.
try {
adapter.getBluetoothLeScanner().startScan(null, getScanSettings(), getScanCallback());
} catch (SecurityException e) {
/* This should never happen because we call this from startDiscovery,
which checks ensureBluetoothReady. But we add try...catch to stop Android Studio errors */
LOG.error("SecurityException on startScan");
}
LOG.debug("Bluetooth LE discovery started successfully");
bluetoothLEProgress.setVisibility(View.VISIBLE);
setScanning(true);
}
private void stopBLEDiscovery() {
if (adapter == null) {
return;
}
BluetoothLeScanner bluetoothLeScanner = adapter.getBluetoothLeScanner();
if (bluetoothLeScanner == null) {
LOG.warn("Could not get BluetoothLeScanner()!");
return;
}
if (newBLEScanCallback == null) {
LOG.warn("newLeScanCallback == null!");
return;
}
try {
bluetoothLeScanner.stopScan(newBLEScanCallback);
} catch (NullPointerException e) {
LOG.warn("Internal NullPointerException when stopping the scan!");
return;
} catch (SecurityException e) {
/* This should never happen because ensureBluetoothReady should set adaptor=null,
but we add try...catch to stop Android Studio errors */
LOG.error("SecurityException on adapter.stopScan");
}
LOG.debug("Stopped BLE discovery");
}
/**
* Starts a regular Bluetooth scan
*/
private void startBTDiscovery() {
LOG.info("Starting BT discovery");
try {
// LineageOS quirk, can't start scan properly,
// if scan has been started by something else
stopBTDiscovery();
} catch (Exception ignored) {
}
handler.removeMessages(0, stopRunnable);
handler.sendMessageDelayed(getPostMessage(stopRunnable), SCAN_DURATION);
try {
if (adapter.startDiscovery()) {
LOG.debug("Discovery started successfully");
bluetoothProgress.setVisibility(View.VISIBLE);
} else {
LOG.error("Discovery starting failed");
}
} catch (SecurityException e) {
/* This should never happen because we call this from startDiscovery,
which checks ensureBluetoothReady. But we add try...catch to stop Android Studio errors */
LOG.error("BluetoothAdaptor.startDiscovery failed with SecurityException");
}
}
private void stopBTDiscovery() {
if (adapter == null) return;
try {
adapter.cancelDiscovery();
} catch (SecurityException e) {
/* This should never happen because ensureBluetoothReady should set adaptor=null,
but we add try...catch to stop Android Studio errors */
LOG.error("BluetoothAdaptor.cancelDiscovery failed with SecurityException");
}
LOG.info("Stopped BT discovery");
}
private void bluetoothStateChanged(int newState) {
if (newState == BluetoothAdapter.STATE_ON) {
this.adapter = BluetoothAdapter.getDefaultAdapter();
startButton.setEnabled(true);
} else {
this.adapter = null;
startButton.setEnabled(false);
bluetoothProgress.setVisibility(View.GONE);
bluetoothLEProgress.setVisibility(View.GONE);
}
}
private boolean checkBluetoothAvailable() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
LOG.warn("No BLUETOOTH_SCAN permission");
this.adapter = null;
return false;
}
if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
LOG.warn("No BLUETOOTH_CONNECT permission");
this.adapter = null;
return false;
}
}
BluetoothManager bluetoothService = (BluetoothManager) getSystemService(BLUETOOTH_SERVICE);
if (bluetoothService == null) {
LOG.warn("No bluetooth service available");
this.adapter = null;
return false;
}
BluetoothAdapter adapter = bluetoothService.getAdapter();
if (adapter == null) {
LOG.warn("No bluetooth adapter available");
this.adapter = null;
return false;
}
if (!adapter.isEnabled()) {
LOG.warn("Bluetooth not enabled");
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
try {
startActivity(enableBtIntent);
} catch (SecurityException e) {
/* This should never happen because we did checkSelfPermission above.
But we add try...catch to stop Android Studio errors */
LOG.warn("startActivity(enableBtIntent) failed with SecurityException");
}
this.adapter = null;
return false;
}
this.adapter = adapter;
if (GB.supportsBluetoothLE())
this.bluetoothLeScanner = adapter.getBluetoothLeScanner();
return true;
}
private boolean ensureBluetoothReady() {
boolean available = checkBluetoothAvailable();
startButton.setEnabled(available);
if (available) {
try {
adapter.cancelDiscovery();
} catch (SecurityException e) {
/* This should never happen because checkBluetoothAvailable should return false
if we don't have permissions. But we add try...catch to stop Android Studio errors */
LOG.error("SecurityException on adapter.cancelDiscovery, but checkBluetoothAvailable()=true!");
}
// must not return the result of cancelDiscovery()
// appears to return false when currently not scanning
return true;
}
return false;
}
private ScanSettings getScanSettings() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
return new ScanSettings.Builder()
.setCallbackType(CallbackType)
.setScanMode(android.bluetooth.le.ScanSettings.SCAN_MODE_LOW_LATENCY)
.setMatchMode(MatchMode)
.setPhy(android.bluetooth.le.ScanSettings.PHY_LE_ALL_SUPPORTED)
.setNumOfMatches(android.bluetooth.le.ScanSettings.MATCH_NUM_ONE_ADVERTISEMENT)
.build();
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
return new ScanSettings.Builder()
.setCallbackType(CallbackType)
.setScanMode(android.bluetooth.le.ScanSettings.SCAN_MODE_LOW_LATENCY)
.setMatchMode(MatchMode)
.setNumOfMatches(android.bluetooth.le.ScanSettings.MATCH_NUM_ONE_ADVERTISEMENT)
.build();
} else {
return new ScanSettings.Builder()
.setScanMode(android.bluetooth.le.ScanSettings.SCAN_MODE_LOW_LATENCY)
.build();
}
}
private List<ScanFilter> getScanFilters() {
List<ScanFilter> allFilters = new ArrayList<>();
for (DeviceType type : DeviceType.values()) {
allFilters.addAll(type.getDeviceCoordinator().createBLEScanFilters());
}
return allFilters;
}
private Message getPostMessage(Runnable runnable) {
Message message = Message.obtain(handler, runnable);
message.obj = runnable;
return message;
}
private void checkAndRequestLocationPermission() {
/* This is more or less a copy of what's in ControlCenterv2, but
we do this in case the permissions weren't requested since there
is no way we can scan without this stuff */
List<String> wantedPermissions = new ArrayList<>();
if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
LOG.error("No permission to access coarse location!");
wantedPermissions.add(Manifest.permission.ACCESS_COARSE_LOCATION);
}
if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
LOG.error("No permission to access fine location!");
wantedPermissions.add(Manifest.permission.ACCESS_FINE_LOCATION);
}
// if we need location permissions, request both together to avoid a bunch of dialogs
if (wantedPermissions.size() > 0) {
toast(DiscoveryActivity.this, getString(R.string.error_no_location_access), Toast.LENGTH_SHORT, GB.ERROR);
ActivityCompat.requestPermissions(this, wantedPermissions.toArray(new String[0]), 0);
wantedPermissions.clear();
}
// Now we have to request background location separately!
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_BACKGROUND_LOCATION) != PackageManager.PERMISSION_GRANTED) {
LOG.error("No permission to access background location!");
toast(DiscoveryActivity.this, getString(R.string.error_no_location_access), Toast.LENGTH_SHORT, GB.ERROR);
ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_BACKGROUND_LOCATION}, 0);
}
}
// Now, we can request Bluetooth permissions....
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
LOG.error("No permission to access Bluetooth scanning!");
toast(DiscoveryActivity.this, getString(R.string.error_no_bluetooth_scan), Toast.LENGTH_SHORT, GB.ERROR);
wantedPermissions.add(Manifest.permission.BLUETOOTH_SCAN);
}
if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
LOG.error("No permission to access Bluetooth connection!");
toast(DiscoveryActivity.this, getString(R.string.error_no_bluetooth_connect), Toast.LENGTH_SHORT, GB.ERROR);
wantedPermissions.add(Manifest.permission.BLUETOOTH_CONNECT);
}
}
if (wantedPermissions.size() > 0) {
GB.toast(this, getString(R.string.permission_granting_mandatory), Toast.LENGTH_LONG, GB.ERROR);
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
ActivityCompat.requestPermissions(this, wantedPermissions.toArray(new String[0]), 0);
} else {
ActivityResultLauncher<String[]> requestMultiplePermissionsLauncher =
registerForActivityResult(new ActivityResultContracts.RequestMultiplePermissions(), isGranted -> {
if (!isGranted.containsValue(false)) {
// Permission is granted. Continue the action or workflow in your app.
// should we do startDiscovery here??
} else {
// Explain to the user that the feature is unavailable because the feature requires a permission that the user has denied.
GB.toast(this, getString(R.string.permission_granting_mandatory), Toast.LENGTH_LONG, GB.ERROR);
}
});
requestMultiplePermissionsLauncher.launch(wantedPermissions.toArray(new String[0]));
}
}
LocationManager locationManager = (LocationManager) DiscoveryActivity.this.getSystemService(Context.LOCATION_SERVICE);
try {
if (locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) || locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {
// Do nothing
LOG.debug("Some location provider is enabled, assuming location is enabled");
} else {
toast(DiscoveryActivity.this, getString(R.string.require_location_provider), Toast.LENGTH_LONG, GB.ERROR);
DiscoveryActivity.this.startActivity(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS));
// We can't be sure location was enabled, cancel scan start and wait for new user action
toast(DiscoveryActivity.this, getString(R.string.error_location_enabled_mandatory), Toast.LENGTH_SHORT, GB.ERROR);
return;
}
} catch (Exception ex) {
LOG.error("Exception when checking location status: ", ex);
}
LOG.info("Permissions seems to be fine for scanning");
}
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
GBDeviceCandidate deviceCandidate = deviceCandidates.get(position);
if (deviceCandidate == null) {
LOG.error("Device candidate clicked, but item not found");
return;
}
if (!deviceCandidate.getDeviceType().isSupported()) {
LOG.error("Unsupported device candidate");
ArrayList deviceDetails = new ArrayList<>();
deviceDetails.add(deviceCandidate.getName());
deviceDetails.add(deviceCandidate.getMacAddress());
try {
for (ParcelUuid uuid : deviceCandidate.getServiceUuids()) {
deviceDetails.add(uuid.getUuid().toString());
}
} catch (Exception e) {
LOG.error("Error collecting device uuids: " + e);
}
String clipboardData = TextUtils.join(", ", deviceDetails);
ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
ClipData clip = ClipData.newPlainText(deviceCandidate.getName(), clipboardData);
clipboard.setPrimaryClip(clip);
toast(this, "Device details copied to clipboard", Toast.LENGTH_SHORT, GB.INFO);
return;
}
stopDiscovery();
DeviceCoordinator coordinator = DeviceHelper.getInstance().resolveCoordinator(deviceCandidate);
LOG.info("Using device candidate " + deviceCandidate + " with coordinator: " + coordinator.getClass());
if (coordinator.getBondingStyle() == DeviceCoordinator.BONDING_STYLE_REQUIRE_KEY) {
SharedPreferences sharedPrefs = GBApplication.getDeviceSpecificSharedPrefs(deviceCandidate.getMacAddress());
String authKey = sharedPrefs.getString("authkey", null);
if (authKey == null || authKey.isEmpty()) {
toast(DiscoveryActivity.this, getString(R.string.discovery_need_to_enter_authkey), Toast.LENGTH_LONG, GB.WARN);
return;
} else if (authKey.getBytes().length < 34 || !authKey.startsWith("0x")) {
toast(DiscoveryActivity.this, getString(R.string.discovery_entered_invalid_authkey), Toast.LENGTH_LONG, GB.WARN);
return;
}
}
Class<? extends Activity> pairingActivity = coordinator.getPairingActivity();
if (pairingActivity != null) {
Intent intent = new Intent(this, pairingActivity);
intent.putExtra(DeviceCoordinator.EXTRA_DEVICE_CANDIDATE, deviceCandidate);
startActivity(intent);
} else {
if (coordinator.getBondingStyle() == DeviceCoordinator.BONDING_STYLE_NONE ||
coordinator.getBondingStyle() == DeviceCoordinator.BONDING_STYLE_LAZY) {
LOG.info("No bonding needed, according to coordinator, so connecting right away");
BondingUtil.connectThenComplete(this, deviceCandidate);
return;
}
try {
this.deviceTarget = deviceCandidate;
BondingUtil.initiateCorrectBonding(this, deviceCandidate, coordinator);
} catch (Exception e) {
LOG.error("Error pairing device: " + deviceCandidate.getMacAddress());
}
}
}
@Override
public boolean onItemLongClick(AdapterView<?> adapterView, View view, int position, long id) {
stopDiscovery();
final GBDeviceCandidate deviceCandidate = deviceCandidates.get(position);
if (deviceCandidate == null) {
LOG.error("Device candidate clicked, but item not found");
return true;
}
if (!deviceCandidate.getDeviceType().isSupported()) {
LOG.error("Unsupported device candidate");
Map<String, Pair<Long, Integer>> allDevices = DebugActivity.getAllSupportedDevices(getApplicationContext());
final LinearLayout linearLayout = new LinearLayout(DiscoveryActivity.this);
linearLayout.setOrientation(LinearLayout.VERTICAL);
final LinearLayout macLayout = new LinearLayout(DiscoveryActivity.this);
macLayout.setOrientation(LinearLayout.HORIZONTAL);
macLayout.setPadding(20, 0, 20, 0);
final Spinner deviceListSpinner = new Spinner(DiscoveryActivity.this);
ArrayList<SpinnerWithIconItem> deviceListArray = new ArrayList<>();
for (Map.Entry<String, Pair<Long, Integer>> item : allDevices.entrySet()) {
deviceListArray.add(new SpinnerWithIconItem(item.getKey(), item.getValue().first, item.getValue().second));
}
final SpinnerWithIconAdapter deviceListAdapter = new SpinnerWithIconAdapter(DiscoveryActivity.this,
R.layout.spinner_with_image_layout, R.id.spinner_item_text, deviceListArray);
deviceListSpinner.setAdapter(deviceListAdapter);
addListenerOnSpinnerDeviceSelection(deviceListSpinner);
linearLayout.addView(deviceListSpinner);
linearLayout.addView(macLayout);
new MaterialAlertDialogBuilder(DiscoveryActivity.this)
.setCancelable(true)
.setTitle(R.string.add_test_device)
.setView(linearLayout)
.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
if (selectedUnsupportedDeviceKey != DebugActivity.SELECT_DEVICE) {
DebugActivity.createTestDevice(DiscoveryActivity.this, selectedUnsupportedDeviceKey, deviceCandidate.getMacAddress());
finish();
}
}
})
.setNegativeButton(R.string.Cancel, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
}
})
.show();
return true;
}
DeviceCoordinator coordinator = DeviceHelper.getInstance().resolveCoordinator(deviceCandidate);
GBDevice device = DeviceHelper.getInstance().toSupportedDevice(deviceCandidate);
if (coordinator.getSupportedDeviceSpecificSettings(device) == null) {
return true;
}
Intent startIntent;
startIntent = new Intent(this, DeviceSettingsActivity.class);
startIntent.putExtra(GBDevice.EXTRA_DEVICE, device);
if (coordinator.getBondingStyle() == DeviceCoordinator.BONDING_STYLE_REQUIRE_KEY) {
startIntent.putExtra(DeviceSettingsActivity.MENU_ENTRY_POINT, DeviceSettingsActivity.MENU_ENTRY_POINTS.AUTH_SETTINGS);
} else {
startIntent.putExtra(DeviceSettingsActivity.MENU_ENTRY_POINT, DeviceSettingsActivity.MENU_ENTRY_POINTS.DEVICE_SETTINGS);
}
startActivity(startIntent);
return true;
}
private void addListenerOnSpinnerDeviceSelection(Spinner spinner) {
spinner.setOnItemSelectedListener(new CustomOnDeviceSelectedListener());
}
public void onBondingComplete(boolean success) {
finish();
}
public GBDeviceCandidate getCurrentTarget() {
return this.deviceTarget;
}
public void unregisterBroadcastReceivers() {
AndroidUtils.safeUnregisterBroadcastReceiver(this, bluetoothReceiver);
}
public void registerBroadcastReceivers() {
IntentFilter bluetoothIntents = new IntentFilter();
bluetoothIntents.addAction(BluetoothDevice.ACTION_FOUND);
bluetoothIntents.addAction(BluetoothDevice.ACTION_UUID);
bluetoothIntents.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
bluetoothIntents.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
bluetoothIntents.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
registerReceiver(bluetoothReceiver, bluetoothIntents);
}
private void loadSettingsValues() {
Prefs prefs = GBApplication.getPrefs();
ignoreBonded = prefs.getBoolean("ignore_bonded_devices", true);
discoverUnsupported = prefs.getBoolean("discover_unsupported_devices", false);
int level = prefs.getInt("scanning_intensity", 1);
switch (level) {
case 0:
CallbackType = android.bluetooth.le.ScanSettings.CALLBACK_TYPE_FIRST_MATCH;
MatchMode = android.bluetooth.le.ScanSettings.MATCH_MODE_STICKY;
break;
case 1:
CallbackType = android.bluetooth.le.ScanSettings.CALLBACK_TYPE_FIRST_MATCH;
MatchMode = android.bluetooth.le.ScanSettings.MATCH_MODE_AGGRESSIVE;
break;
case 2:
CallbackType = android.bluetooth.le.ScanSettings.CALLBACK_TYPE_ALL_MATCHES;
MatchMode = android.bluetooth.le.ScanSettings.MATCH_MODE_STICKY;
break;
case 3:
CallbackType = android.bluetooth.le.ScanSettings.CALLBACK_TYPE_ALL_MATCHES;
MatchMode = android.bluetooth.le.ScanSettings.MATCH_MODE_AGGRESSIVE;
break;
}
LOG.debug("Device discovery - scanning level: " + level + " " + CallbackType + " " + MatchMode);
}
@Override
public Context getContext() {
return this;
}
public class CustomOnDeviceSelectedListener implements AdapterView.OnItemSelectedListener {
public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
SpinnerWithIconItem selectedItem = (SpinnerWithIconItem) parent.getItemAtPosition(pos);
selectedUnsupportedDeviceKey = selectedItem.getId();
}
@Override
public void onNothingSelected(AdapterView<?> arg0) {
// TODO Auto-generated method stub
}
}
private class BTUUIDPair {
private final BluetoothDevice bluetoothDevice;
private final ParcelUuid[] parcelUuid;
public BTUUIDPair(BluetoothDevice bluetoothDevice, ParcelUuid[] parcelUuid) {
this.bluetoothDevice = bluetoothDevice;
this.parcelUuid = parcelUuid;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
BTUUIDPair that = (BTUUIDPair) o;
return bluetoothDevice.equals(that.bluetoothDevice) && Arrays.equals(parcelUuid, that.parcelUuid);
}
@Override
public int hashCode() {
int result = Objects.hash(bluetoothDevice);
result = 31 * result + Arrays.hashCode(parcelUuid);
return result;
}
}
}

24
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/activities/discovery/DiscoveryActivityV2.java
View File

@ -472,36 +472,12 @@ public class DiscoveryActivityV2 extends AbstractGBActivity implements AdapterVi
}
private static ScanSettings getScanSettings() {
final Prefs prefs = GBApplication.getPrefs();
final int level = prefs.getInt("scanning_intensity", 1);
final ScanSettings.Builder builder = new ScanSettings.Builder()
.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY);
LOG.debug("Device discovery - scanning level: {}", level);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
switch (level) {
case 0:
builder.setCallbackType(ScanSettings.CALLBACK_TYPE_FIRST_MATCH);
builder.setMatchMode(ScanSettings.MATCH_MODE_STICKY);
break;
case 1:
builder.setCallbackType(ScanSettings.CALLBACK_TYPE_FIRST_MATCH);
builder.setMatchMode(ScanSettings.MATCH_MODE_AGGRESSIVE);
break;
case 2:
builder.setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES);
builder.setMatchMode(ScanSettings.MATCH_MODE_STICKY);
break;
case 3:
builder.setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES);
builder.setMatchMode(ScanSettings.MATCH_MODE_AGGRESSIVE);
break;
default:
LOG.warn("Unknown intensity level {}", level);
}
builder.setNumOfMatches(ScanSettings.MATCH_NUM_ONE_ADVERTISEMENT);
}

6
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/devices/lenovo/LenovoWatchPairingActivity.java
View File

@ -33,11 +33,9 @@ import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import nodomain.freeyourgadget.gadgetbridge.GBApplication;
import nodomain.freeyourgadget.gadgetbridge.R;
import nodomain.freeyourgadget.gadgetbridge.activities.AbstractGBActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.ControlCenterv2;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivityV2;
import nodomain.freeyourgadget.gadgetbridge.devices.DeviceCoordinator;
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
@ -67,11 +65,7 @@ public class LenovoWatchPairingActivity extends AbstractGBActivity implements Bo
}
if (deviceCandidate == null) {
Toast.makeText(this, getString(R.string.message_cannot_pair_no_mac), Toast.LENGTH_SHORT).show();
if (GBApplication.useNewDiscoveryActivity()) {
startActivity(new Intent(this, DiscoveryActivityV2.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
} else {
startActivity(new Intent(this, DiscoveryActivity.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
}
finish();
return;
}

6
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/devices/miband/MiBandPairingActivity.java
View File

@ -41,7 +41,6 @@ import nodomain.freeyourgadget.gadgetbridge.R;
import nodomain.freeyourgadget.gadgetbridge.activities.AboutUserPreferencesActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.AbstractGBActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.ControlCenterv2;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivityV2;
import nodomain.freeyourgadget.gadgetbridge.devices.DeviceCoordinator;
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
@ -77,11 +76,8 @@ public class MiBandPairingActivity extends AbstractGBActivity implements Bonding
if (deviceCandidate == null) {
Toast.makeText(this, getString(R.string.message_cannot_pair_no_mac), Toast.LENGTH_SHORT).show();
if (GBApplication.useNewDiscoveryActivity()) {
startActivity(new Intent(this, DiscoveryActivityV2.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
} else {
startActivity(new Intent(this, DiscoveryActivity.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
}
finish();
return;
}

5
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/devices/pebble/PebblePairingActivity.java
View File

@ -42,7 +42,6 @@ import nodomain.freeyourgadget.gadgetbridge.GBApplication;
import nodomain.freeyourgadget.gadgetbridge.R;
import nodomain.freeyourgadget.gadgetbridge.activities.AbstractGBActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.ControlCenterv2;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivityV2;
import nodomain.freeyourgadget.gadgetbridge.database.DBHandler;
import nodomain.freeyourgadget.gadgetbridge.devices.DeviceCoordinator;
@ -173,11 +172,7 @@ public class PebblePairingActivity extends AbstractGBActivity implements Bonding
if (success) {
startActivity(new Intent(this, ControlCenterv2.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
} else {
if (GBApplication.useNewDiscoveryActivity()) {
startActivity(new Intent(this, DiscoveryActivityV2.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
} else {
startActivity(new Intent(this, DiscoveryActivity.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
}
}
// If it's not a LE Pebble, initiate a connection when bonding is complete

6
app/src/main/java/nodomain/freeyourgadget/gadgetbridge/devices/watch9/Watch9PairingActivity.java
View File

@ -31,11 +31,9 @@ import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import nodomain.freeyourgadget.gadgetbridge.GBApplication;
import nodomain.freeyourgadget.gadgetbridge.R;
import nodomain.freeyourgadget.gadgetbridge.activities.AbstractGBActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.ControlCenterv2;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivity;
import nodomain.freeyourgadget.gadgetbridge.activities.discovery.DiscoveryActivityV2;
import nodomain.freeyourgadget.gadgetbridge.devices.DeviceCoordinator;
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
@ -65,11 +63,7 @@ public class Watch9PairingActivity extends AbstractGBActivity implements Bonding
if (deviceCandidate == null) {
Toast.makeText(this, getString(R.string.message_cannot_pair_no_mac), Toast.LENGTH_SHORT).show();
if (GBApplication.useNewDiscoveryActivity()) {
startActivity(new Intent(this, DiscoveryActivityV2.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
} else {
startActivity(new Intent(this, DiscoveryActivity.class).setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP));
}
finish();
return;
}

4
app/src/main/res/values/strings.xml
View File

@ -541,8 +541,6 @@
<string name="pref_auto_fetch_limit_fetches">Minimum time between fetches</string>
<string name="pref_auto_fetch_limit_fetches_summary">Fetches every %d minutes</string>
<!-- developer/debug preferences-->
<string name="discovery_scanning_intensity">Scanning intensity</string>
<string name="discovery_scanning_intensity_warning">If you experience freezing or unresponsiveness, try to set Scanning intensity to lower level. If your device is not being discovered, try to set Scanning intensity to higher level.</string>
<string name="pref_disable_new_ble_scanning">Disable new BLE scanning</string>
<string name="pref_summary_disable_new_ble_scanning">Check this option if your device cannot be found during discovery</string>
<string name="not_connected">Not connected</string>
@ -1617,8 +1615,6 @@
<string name="ignore_bonded_devices_description">Enabling this option will ignore devices that have been bonded/paired already when scanning</string>
<string name="discover_unsupported_devices">Discover unsupported devices</string>
<string name="discover_unsupported_devices_description">Enabling this option will display all discovered bluetooth devices when scanning. Short tap will copy device name and mac address to clipboard. Long press will launch `Add test device` dialog. Can cause potential app freezing issues.</string>
<string name="new_discover_activity_title">Enable new discover activity</string>
<string name="new_discover_activity_description">Enable the new discover activity, which should fix device discovery issues. Disable this if you face any issues while searching for or pairing with your device.</string>
<string name="error_location_enabled_mandatory">Location must be turned on to scan for devices</string>
<string name="sonyswr12_settings_title">Sony SWR12 Settings</string>
<string name="sonyswr12_settings_low_vibration">Low vibration enabled</string>

20
app/src/main/res/xml/discovery_pairing_preferences.xml
View File

@ -23,24 +23,4 @@
android:summary="@string/discover_unsupported_devices_description"
android:title="@string/discover_unsupported_devices"
app:iconSpaceReserved="false" />
<SwitchPreference
android:defaultValue="true"
android:key="new_discover_activity"
android:layout="@layout/preference_checkbox"
android:summary="@string/new_discover_activity_description"
android:title="@string/new_discover_activity_title"
app:iconSpaceReserved="false" />
<SeekBarPreference
android:defaultValue="1"
android:key="scanning_intensity"
android:max="3"
android:min="0"
android:title="@string/discovery_scanning_intensity"
app:iconSpaceReserved="false"
app:showSeekBarValue="true" />
<Preference
android:persistent="false"
android:selectable="false"
android:summary="@string/discovery_scanning_intensity_warning"
app:iconSpaceReserved="false" />
</PreferenceScreen>