Hey Omri, let's tackle that annoying intermittent BLE scan failure you're seeing. The "app registration failed" error usually points to issues with how your app interacts with the system's Bluetooth stack—either timing problems, resource leaks, or missing setup steps. Let's break down the possible causes and fixes based on your code:

1. Bluetooth Adapter Isn't Fully Ready When You Start Scanning #

Your current code uses a fixed 5-second delay in searchDevice() if Bluetooth is already enabled, but this is a one-size-fits-all approach that might not work for all devices. Some devices take longer to initialize the BLE stack after Bluetooth is turned on, especially if it's just been enabled via ACTION_REQUEST_ENABLE.

Fix: Listen for Bluetooth State Changes Instead of Fixed Delays #

Instead of relying on a hardcoded delay, register a BroadcastReceiver to listen for when Bluetooth is fully turned on (BluetoothAdapter.STATE_ON), then start scanning only after that event fires. This ensures the stack is ready before you attempt to scan:

// Add this to your Bluetooth class
private BroadcastReceiver bluetoothStateReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        final String action = intent.getAction();
        if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {
            final int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR);
            switch (state) {
                case BluetoothAdapter.STATE_ON:
                    // Now Bluetooth is fully ready—start scanning
                    scanLeDevice(true);
                    break;
                case BluetoothAdapter.STATE_OFF:
                    // Handle Bluetooth being turned off
                    scanLeDevice(false);
                    break;
            }
        }
    }
};

// Register the receiver when initializing, unregister when done
public Bluetooth(Context context, MainActivity activity) {
    this.mContext = context;
    this.mActivity = activity;
    mHandler = new Handler();
    
    // Initialize Bluetooth manager
    final BluetoothManager bluetoothManager = (BluetoothManager) mContext.getSystemService(Context.BLUETOOTH_SERVICE);
    mBTAdapter = bluetoothManager.getAdapter();
    mBluetoothLeScanner = mBTAdapter.getBluetoothLeScanner();

    if (mBTAdapter == null) {
        Toast.makeText(mContext, "Bluetooth device not found!", Toast.LENGTH_SHORT).show();
    } else {
        if (!mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
            Toast.makeText(mContext, "No BLE feature in phone", Toast.LENGTH_SHORT).show();
            return;
        }

        // Register receiver for state changes
        IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
        mContext.registerReceiver(bluetoothStateReceiver, filter);

        if (mBTAdapter.isEnabled()) {
            // If already on, wait a short time to ensure stack is ready
            mHandler.postDelayed(() -> scanLeDevice(true), 1000);
        } else {
            Toast.makeText(mContext, "To begin please turn on bluetooth", Toast.LENGTH_SHORT).show();
            Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            mActivity.startActivityForResult(enableBtIntent, MainActivity.REQUEST_ENABLE_BT);
        }
    }
}

// Don't forget to unregister the receiver to avoid leaks!
public void cleanup() {
    try {
        mContext.unregisterReceiver(bluetoothStateReceiver);
    } catch (IllegalArgumentException e) {
        // Receiver wasn't registered, ignore
    }
    scanLeDevice(false);
    disconnect();
    close();
}

Make sure to call cleanup() from your MainActivity's onDestroy() method to avoid resource leaks.

2. Unmanaged Scan Resources & Duplicate Scan Requests #

Looking at your scanLeDevice() method: if scanLeDevice(true) is called multiple times (e.g., if the user triggers a scan again before the previous one stops), you might end up with overlapping scan requests, which can confuse the Bluetooth stack and lead to registration failures.

Fix: Guard Against Duplicate Scans #

Add a check to ensure you don't start a scan if one's already running:

private void scanLeDevice(final boolean enable) {
    if (enable) {
        if (mScanning) {
            // Already scanning—do nothing
            return;
        }
        // Stop scan after SCAN_PERIOD
        mHandler.postDelayed(() -> {
            mScanning = false;
            mBluetoothLeScanner.stopScan(leScanCallback);
        }, SCAN_PERIOD);
        mScanning = true;
        Log.d("ADebugTag", "Starting BLE scan");
        mBluetoothLeScanner.startScan(leScanCallback);
    } else {
        if (!mScanning) {
            return;
        }
        mScanning = false;
        mBluetoothLeScanner.stopScan(leScanCallback);
        Log.d("ADebugTag", "Stopped BLE scan");
    }
}

Also, make sure to stop scans when your app goes to the background (e.g., in MainActivity.onPause() call bluetooth.scanLeDevice(false)).

3. GATT Resource Leaks #

Your Bluetooth constructor calls disconnect() and close() right away, but at that point mBTGatt is null, so those calls do nothing. If you're creating multiple instances of the Bluetooth class (or not properly cleaning up old ones), leftover GATT connections can hog resources and interfere with scanning.

Fix: Properly Clean Up GATT Resources #

• Always call disconnect() and close() when you're done with a GATT connection (e.g., when the device disconnects, or when the app closes).
• Avoid trying to access GATT services/characteristics before onServicesDiscovered() is called—your current connect() method tries to get the characteristic immediately after calling connectGatt(), which will always throw a NullPointerException because services haven't been discovered yet. Move that code to the onServicesDiscovered() callback where it belongs:

public boolean connect() {
    mActivity.updatesStatus(MainActivity.STATE_CONNECTING,"","");
    BTdevice = mBTAdapter.getRemoteDevice(devcAddress);
    mBTGatt = BTdevice.connectGatt(mContext, false, mGattCallback);
    
    if (mBTGatt == null){
        Log.d("ADebugTag", "mBTGatt is null");
        return false;
    }
    return true;
}

// In onServicesDiscovered:
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
    if (status == BluetoothGatt.GATT_SUCCESS) {
        broadcastUpdate(ACTION_GATT_SERVICES_DISCOVERED);
        BluetoothGattService service = gatt.getService(ServiceUUID);
        if (service != null) {
            mGattChar = service.getCharacteristic(CharUUID);
            if (mGattChar != null) {
                setCharacteristicNotification(mGattChar, true);
            } else {
                Log.d("ADebugTag", "Target characteristic not found");
            }
        } else {
            Log.d("ADebugTag", "Target service not found");
        }
    } else {
        Log.d("ADebugTag", "onServicesDiscovered received:" + status);
    }
}

4. Missing Runtime Permissions (Android 6.0+) #

BLE scanning requires location permissions (ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION) on Android 6.0 and above. If your app doesn't have these permissions granted, scanning might fail intermittently (especially if the system revokes temporary permission).

Fix: Ensure Location Permissions Are Granted #

Add the permissions to your AndroidManifest.xml:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" /> <!-- For Android 12+ -->
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /> <!-- For Android 12+ -->

And request them at runtime in your MainActivity:

// Check for location permissions
private void checkLocationPermissions() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_LOCATION_PERMISSION);
    }
}

Final Notes #

The "app registration failed" error often stems from race conditions with the Bluetooth stack or resource leaks. By waiting for the Bluetooth adapter to be fully ready, properly managing scan lifecycles, cleaning up GATT resources, and ensuring permissions are in place, you should see the intermittent failures disappear.

内容的提问来源于stack exchange，提问作者Omri