【 Android蓝牙-十】Android各版本蓝牙行为变化与兼容性指南

一、引言

在Android蓝牙开发中，开发者常常面临一个困境：同样的代码在不同设备上、不同Android版本上表现不同。有时连接稳定，有时断断续续；有时能在后台正常工作，有时却默默停止。这种不一致性主要源于：

• Android系统对蓝牙API的持续演进
• 各版本间权限模型的重大变化
• 不同厂商对蓝牙栈的定制与优化
• 电源管理策略差异

本文旨在梳理Android 8.0至14各版本对蓝牙行为的关键变化，提供实用的兼容性解决方案，帮助开发者构建健壮的跨版本蓝牙应用。

二、核心变化：Android 8.0-10

Android 8.0 (Oreo)

Android 8.0引入了多项针对蓝牙功能的限制和变化，这些变化主要为了改善电池性能和用户隐私：

1. 后台蓝牙扫描限制

在Android 8.0之前，应用可以在后台无限制地进行蓝牙扫描，导致严重的电池消耗问题。从Android 8.0开始，系统对后台应用的蓝牙扫描行为进行了严格限制：

• 应用在后台时，强制降低扫描频率，限制为低功耗模式
• 后台应用每30分钟内最多只能进行5次蓝牙扫描操作
• 每次扫描时长限制在30秒以内
• 如果应用频繁违反这些限制，系统会自动抑制其扫描请求

这些限制对于需要持续监控周边蓝牙设备的应用带来了巨大挑战，需要开发者调整扫描策略。

适配方案示例：

// 根据应用状态选择合适的扫描模式
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    if (isAppInForeground()) {
        // 前台可以使用高频扫描
        settings = new ScanSettings.Builder()
                .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
                .build();
    } else {
        // 后台必须使用低功耗模式
        settings = new ScanSettings.Builder()
                .setScanMode(ScanSettings.SCAN_MODE_LOW_POWER)
                .build();
    }
}

2. 位置权限强制要求

虽然从Android 6.0开始就要求蓝牙扫描需要位置权限，但从Android 8.0开始，这一要求更加严格且不可规避：

• 蓝牙扫描必须有ACCESS_FINE_LOCATION或ACCESS_COARSE_LOCATION权限
• 权限检查更严格，没有权限时扫描结果为空而非异常
• 位置服务必须开启，否则无法获得扫描结果（即使已获得权限）
• 权限未授予时会静默失败，不会抛出明显异常

这样设计是因为BLE广播中包含的信息可能泄露用户位置，因此被归类为位置敏感操作。开发者必须清晰向用户说明为什么蓝牙功能需要位置权限。

Android 9.0 (Pie)

1. MAC地址随机化

Android 9.0引入了重要的隐私保护特性------蓝牙扫描MAC地址随机化：

• 默认情况下，当应用扫描周围蓝牙设备时，不再能获取真实MAC地址
• 系统会生成随机MAC地址，并且这些地址会定期变化
• 这项变化显著提高了用户隐私，防止了通过蓝牙MAC进行的用户追踪
• 但同时也使得依赖MAC地址作为唯一标识符的应用面临巨大挑战

这意味着开发者必须改变设备识别策略，不能再依赖MAC地址作为设备唯一标识符。相反，应该：

• 使用广播数据包中的特定标识符（如制造商数据、服务UUID等）
• 建立设备特征指纹（信号特征、广播内容特征等）
• 设计配对后的认证机制，不依赖扫描阶段识别

2. 扫描节流机制

Android 9.0大幅增强了对频繁蓝牙扫描的限制：

• 5分钟内同一应用的蓝牙扫描操作超过5次会触发系统节流
• 节流后，扫描操作会被延迟执行或完全不执行
• 系统会自动根据应用的使用频率和电池状态调整节流策略
• 后台应用的节流更为严格，几乎无法进行高频扫描

这些变化要求开发者彻底重新设计扫描策略：

• 减少扫描频率，增大扫描间隔
• 实现基于事件的扫描而非周期性扫描
• 增强扫描结果的缓存和复用机制
• 优化前台服务的使用，提高扫描优先级

Android 10

1. 后台位置权限限制

Android 10对位置权限进行了重大改革，引入了"仅在使用应用时允许"的位置权限概念，这对蓝牙操作产生了深远影响：

• 将位置权限分为前台位置权限和后台位置权限
• 默认情况下，用户只能授予前台位置权限，必须通过额外步骤才能授予后台位置权限
• 用户可以明确拒绝应用在后台获取位置信息，即使之前已经授予过权限
• 蓝牙扫描作为位置敏感操作，完全受这一权限模型约束

这意味着，即使用户已经授予了位置权限，应用在后台时也无法使用蓝牙扫描功能，除非明确获得了ACCESS_BACKGROUND_LOCATION权限。获取这个权限需要特殊的请求流程和明确的用户授权。

2. 蓝牙操作影响

Android 10的权限模型变化对蓝牙操作带来了多方面影响：

• 后台扫描受限：没有后台位置权限时，应用进入后台后无法获取新的扫描结果
• 连接稳定性下降：设备连接在后台更容易被系统中断或资源回收
• 前台服务重要性提升：维持稳定蓝牙连接几乎必须依赖前台服务
• 用户体验挑战：需要清晰解释为什么应用需要后台位置权限
• 电源管理限制增强：后台应用的蓝牙操作更容易受到系统电源管理策略的影响

这些变化使得开发持续监控类蓝牙应用（如健康监测、位置追踪、IoT控制等）变得更加困难，需要精心设计权限请求流程和用户体验。

三、重大转变：Android 11-14

Android 11

1. 一次性权限与相邻设备权限概念

Android 11在权限模型上引入了两项重大创新，显著影响了蓝牙应用开发：

• 一次性权限：允许用户临时授予应用敏感权限，应用下次启动时权限会自动撤销
• 相邻设备权限概念：开始重新审视蓝牙等近场通信技术的权限模型

一次性权限机制意味着蓝牙应用必须做好权限可能随时被撤销的准备，每次启动都需要检查并可能重新请求权限。虽然正式的蓝牙专用权限要到Android 12才完全实现，但Android 11开始为此奠定基础。

此外，Android 11进一步完善了权限授予流程，特别是对于敏感权限，系统会提供更详细的解释和限制。

2. 后台位置访问限制增强

Android 11对后台位置访问施加了更严格的限制：

• 应用不能在同一界面同时请求前台和后台位置权限
• 必须先获得前台位置权限，然后才能请求后台位置权限
• 后台位置权限请求必须将用户引导至系统设置页面，不能通过标准对话框获取
• 系统会自动对长期不使用的应用撤销敏感权限，包括位置权限

这些变化对蓝牙应用产生了深远影响：

• 需要重新设计权限请求流程，采用多步骤请求策略
• 应用必须清晰解释为什么需要后台位置权限
• 必须实现权限被撤销时的优雅降级机制
• 需要更频繁地检查权限状态，不能假设一次授权永久有效

Android 12

1. 蓝牙专用权限体系

Android 12实现了蓝牙权限体系的重大变革，这是自Android 6.0以来蓝牙权限的最大调整：

• 正式引入了专用的蓝牙权限，将蓝牙操作与位置权限解耦
• 新增了BLUETOOTH_SCAN和BLUETOOTH_CONNECT两个核心权限
• BLUETOOTH_SCAN用于控制设备发现和扫描广播
• BLUETOOTH_CONNECT用于控制已知设备的连接、通信和配对
• BLUETOOTH_ADVERTISE用于控制广播发送功能

这一变化意味着纯蓝牙应用（不需要获取位置信息的应用）终于可以不再请求位置权限，大大降低了用户的权限疑虑。同时，权限更加细粒度，用户可以只允许连接但不允许扫描，或反之。

2. 精确位置权限与蓝牙权限分离

Android 12实现了蓝牙扫描与精确位置权限的完全分离：

• 默认情况下，蓝牙扫描不再需要位置权限
• 但如果应用需要访问扫描结果中的位置相关信息，仍需请求位置权限
• 使用BLUETOOTH_SCAN权限时可以通过android:usesPermissionFlags="neverForLocation"标记声明永不用于位置用途
• 引入了可以不获取位置信息的"无位置"蓝牙扫描模式

这些变化反映了Android系统对隐私保护的重视，同时给纯蓝牙功能应用带来了极大便利。对于多功能应用，需要根据实际功能需求决定是否仍需要请求位置权限。

Android 13/14

1. 权限申请机制变化

Android 13和14在蓝牙权限基础上做了进一步优化和改进：

• 权限请求简化：将相关蓝牙权限组合到"附近设备"权限组中，用户可以一次授予或拒绝
• 更智能的权限对话框：系统提供更详细的权限用途解释和视觉提示
• 权限健康检查：系统会定期审查应用权限使用情况，提醒用户回收不必要的权限
• 差异化权限描述：可以为不同场景下的权限请求提供上下文相关的解释
• 精细的权限使用记录：用户可以查看应用何时、如何使用了敏感权限

这些变化要求开发者更加重视权限请求的用户体验设计，提供清晰的功能解释和权限用途说明。

2. 最新适配要点

Android 13和14对蓝牙功能还有一些值得注意的变化：

• 权限自动重置增强：长期未使用的应用权限会被自动撤销，包括蓝牙权限
• 前台服务权限要求：使用前台服务需要专门的权限声明
• 通知权限分离：前台服务通知需要单独的通知权限
• 近场设备感知API：引入了新的API简化附近设备的发现和连接
• 蓝牙LE音频支持：增强了对蓝牙LE音频设备的支持
• 多设备连接优化：改进了同时连接多个蓝牙设备的性能和稳定性

这些新特性和限制要求开发者重新审视蓝牙功能的实现方式，特别是关于权限请求、前台服务和用户通知的处理逻辑。在设计蓝牙应用时，必须充分考虑用户隐私和系统资源优化。

四、实战指南：构建兼容代码框架

在Android蓝牙开发中，面对不同版本和设备的差异，建立一个统一的兼容性框架至关重要。这不仅能简化开发流程，也能提高应用的稳定性和用户体验。以下是构建这样一个框架的核心策略和思路：

统一适配策略

构建跨版本蓝牙应用的核心理念包括：

这些策略帮助应用在各种条件下保持尽可能好的用户体验，即使在受限环境中也能提供核心功能。

    if (sdkVersion >= Build.VERSION_CODES.O && isBackground) {
        // Android 8.0+后台扫描限制
        builder.setScanMode(ScanSettings.SCAN_MODE_LOW_POWER);
    } else {
        builder.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY);
    }
    
    if (sdkVersion >= Build.VERSION_CODES.M) {
        builder.setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES);
    }
    
    return builder.build();
}

// 厂商特定适配
public void applyManufacturerSpecificFixes(Context context) {
    if (manufacturer.contains("huawei")) {
        // 华为特殊处理
    } else if (manufacturer.contains("xiaomi")) {
        // 小米特殊处理
    }
    // ...其他厂商
}

异常捕获与恢复机制

设计健壮的错误处理机制：

public class BluetoothErrorHandler {
    // 蓝牙操作超时监控
    public void executeWithTimeout(Runnable operation, long timeoutMs, Runnable fallback) {
        final boolean[] completed = {false};
        
        // 执行操作
        Thread operationThread = new Thread(() -> {
            try {
                operation.run();
                completed[0] = true;
            } catch (Exception e) {
                Log.e("BtErrorHandler", "Operation failed", e);
            }
        });
        operationThread.start();
        
        // 超时检查
        try {
            operationThread.join(timeoutMs);
            if (!completed[0]) {
                Log.w("BtErrorHandler", "Operation timed out, executing fallback");
                fallback.run();
            }
        } catch (InterruptedException e) {
            Log.e("BtErrorHandler", "Timeout thread interrupted", e);
        }
    }
    
    // 常见错误处理
    public void handleGattError(int status, BluetoothGatt gatt, 
            Runnable reconnectAction) {
        switch (status) {
            case BluetoothGatt.GATT_CONNECTION_CONGESTED:
                // 连接拥堵，延迟后重试
                new Handler().postDelayed(reconnectAction, 1000);
                break;
                
            case BluetoothGatt.GATT_INSUFFICIENT_AUTHENTICATION:
                // 可能需要配对
                triggerBonding(gatt.getDevice());
                break;
                
            default:
                if (status != BluetoothGatt.GATT_SUCCESS) {
                    // 通用错误处理
                    gatt.close();
                    reconnectAction.run();
                }
                break;
        }
    }
}

六、案例分析

跨版本蓝牙扫描实现

一个完整的、兼容各版本的蓝牙扫描示例：

public class CompatibleBleScannerImpl implements BleScanner {
    private final Context context;
    private final BluetoothAdapter bluetoothAdapter;
    private final BluetoothLeScanner scanner;
    private final BluetoothCompatManager compatManager;
    private final Handler handler = new Handler(Looper.getMainLooper());
    
    // 扫描回调
    private final ScanCallback scanCallback = new ScanCallback() {
        @Override
        public void onScanResult(int callbackType, ScanResult result) {
            // 处理扫描结果
            processDevice(result.getDevice(), result.getScanRecord(), result.getRssi());
        }
        
        @Override
        public void onScanFailed(int errorCode) {
            handleScanError(errorCode);
        }
    };
    
    // 扫描状态控制
    private boolean isScanning = false;
    private boolean isBackground = false;
    private Runnable scanTimeoutRunnable;
    
    public CompatibleBleScannerImpl(Context context) {
        this.context = context;
        BluetoothManager bluetoothManager = (BluetoothManager) 
                context.getSystemService(Context.BLUETOOTH_SERVICE);
        bluetoothAdapter = bluetoothManager.getAdapter();
        scanner = bluetoothAdapter.getBluetoothLeScanner();
        compatManager = BluetoothCompatManager.getInstance();
    }
    
    @Override
    public void startScan(final boolean isBackground) {
        if (isScanning) {
            return;
        }
        
        this.isBackground = isBackground;
        
        // 权限检查
        if (!hasRequiredPermissions()) {
            Log.e("BleScanner", "缺少必要权限");
            return;
        }
        
        try {
            // 适配版本特性的扫描设置
            ScanSettings settings = compatManager.getScanSettings(isBackground);
            
            // 如果是Android 8.0+，需处理后台扫描时间限制
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && isBackground) {
                scanTimeoutRunnable = () -> {
                    if (isScanning) {
                        stopScan();
                        // 延迟后再次启动扫描
                        handler.postDelayed(() -> startScan(true), 300000); // 5分钟后再扫描
                    }
                };
                handler.postDelayed(scanTimeoutRunnable, 30000); // 后台最多扫描30秒
            }
            
            // 启动扫描
            scanner.startScan(null, settings, scanCallback);
            isScanning = true;
            
        } catch (Exception e) {
            Log.e("BleScanner", "启动扫描失败", e);
            // 尝试恢复
            tryRecoverFromError();
        }
    }
    
    @Override
    public void stopScan() {
        if (!isScanning) {
            return;
        }
        
        try {
            scanner.stopScan(scanCallback);
        } catch (Exception e) {
            Log.e("BleScanner", "停止扫描失败", e);
        } finally {
            isScanning = false;
            
            // 清理超时任务
            if (scanTimeoutRunnable != null) {
                handler.removeCallbacks(scanTimeoutRunnable);
            }
        }
    }
    
    private boolean hasRequiredPermissions() {
        String[] permissions = compatManager.getRequiredPermissions();
        
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(context, permission) 
                    != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        
        return true;
    }
    
    private void handleScanError(int errorCode) {
        switch (errorCode) {
            case ScanCallback.SCAN_FAILED_APPLICATION_REGISTRATION_FAILED:
                // 等待系统资源释放后重试
                handler.postDelayed(this::restartScan, 2000);
                break;
                
            case ScanCallback.SCAN_FAILED_FEATURE_UNSUPPORTED:
                // 设备不支持BLE
                Log.e("BleScanner", "设备不支持BLE");
                break;
                
            case ScanCallback.SCAN_FAILED_INTERNAL_ERROR:
                // 内部错误，尝试重启蓝牙
                restartBluetooth();
                break;
                
            case ScanCallback.SCAN_FAILED_ALREADY_STARTED:
                // 已经在扫描了
                isScanning = true;
                break;
        }
    }
    
    // 错误恢复机制
    private void tryRecoverFromError() {
        // 尝试重启蓝牙模块
        if (bluetoothAdapter.isEnabled()) {
            bluetoothAdapter.disable();
            handler.postDelayed(() -> {
                bluetoothAdapter.enable();
                handler.postDelayed(this::restartScan, 3000);
            }, 2000);
        }
    }
    
    private void restartScan() {
        stopScan();
        startScan(isBackground);
    }
    
    private void restartBluetooth() {
        if (bluetoothAdapter.isEnabled()) {
            bluetoothAdapter.disable();
            handler.postDelayed(() -> bluetoothAdapter.enable(), 2000);
        }
    }
}

兼容性连接管理策略

强健的跨版本连接管理器：

public class CompatibleBleConnectionManager {
    private final Context context;
    private final Map<String, BluetoothGatt> activeConnections = new HashMap<>();
    private final BluetoothAdapter bluetoothAdapter;
    
    // 版本适配助手
    private final BluetoothCompatManager compatManager;
    
    // 错误处理器
    private final BluetoothErrorHandler errorHandler = new BluetoothErrorHandler();
    
    public CompatibleBleConnectionManager(Context context) {
        this.context = context;
        BluetoothManager bluetoothManager = (BluetoothManager) 
                context.getSystemService(Context.BLUETOOTH_SERVICE);
        bluetoothAdapter = bluetoothManager.getAdapter();
        compatManager = BluetoothCompatManager.getInstance();
    }
    
    // 连接设备
    public boolean connect(String address, BleGattCallback callback) {
        if (TextUtils.isEmpty(address)) {
            return false;
        }
        
        // 权限检查
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S &&
                ContextCompat.checkSelfPermission(context, 
                        Manifest.permission.BLUETOOTH_CONNECT) != 
                        PackageManager.PERMISSION_GRANTED) {
            return false;
        }
        
        // 获取设备
        final BluetoothDevice device;
        try {
            device = bluetoothAdapter.getRemoteDevice(address);
        } catch (IllegalArgumentException e) {
            Log.e("BleConnection", "非法的设备地址: " + address);
            return false;
        }
        
        // 断开已有连接
        if (activeConnections.containsKey(address)) {
            disconnect(address);
        }
        
        // 创建GATT回调
        BluetoothGattCallback gattCallback = createGattCallback(callback, address);
        
        // 连接策略因版本而异
        BluetoothGatt gatt;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            // Android 8.0+ 支持传输参数
            gatt = device.connectGatt(context, false, gattCallback, 
                    BluetoothDevice.TRANSPORT_LE, 
                    BluetoothDevice.PHY_LE_1M_MASK);
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            // Android 6.0+ 支持指定传输类型
            gatt = device.connectGatt(context, false, gattCallback, 
                    BluetoothDevice.TRANSPORT_LE);
        } else {
            // 老版本Android
            gatt = device.connectGatt(context, false, gattCallback);
        }
        
        // 保存连接
        if (gatt != null) {
            activeConnections.put(address, gatt);
            return true;
        }
        return false;
    }
    
    // 断开连接
    public void disconnect(String address) {
        BluetoothGatt gatt = activeConnections.remove(address);
        if (gatt != null) {
            try {
                gatt.disconnect();
                gatt.close();
            } catch (Exception e) {
                Log.e("BleConnection", "断开连接异常", e);
            }
        }
    }
    
    // 根据系统版本创建适配的回调
    private BluetoothGattCallback createGattCallback(
            final BleGattCallback callback, final String address) {
        return new BluetoothGattCallback() {
            @Override
            public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
                if (status != BluetoothGatt.GATT_SUCCESS) {
                    // 连接错误处理
                    errorHandler.handleGattError(status, gatt, () -> 
                            connect(address, callback));
                    return;
                }
                
                if (newState == BluetoothProfile.STATE_CONNECTED) {
                    // 连接成功
                    
                    // 适配不同版本的服务发现
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                        // Android 8.0+ 延迟以增加稳定性
                        new Handler(Looper.getMainLooper()).postDelayed(() -> 
                                gatt.discoverServices(), 500);
                    } else {
                        gatt.discoverServices();
                    }
                    
                    callback.onConnectSuccess(gatt, address);
                } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                    // 断开连接
                    gatt.close();
                    activeConnections.remove(address);
                    callback.onDisConnected(address);
                }
            }
            
            @Override
            public void onServicesDiscovered(BluetoothGatt gatt