iOS - BLE peripherals aren't scanned on background mode

Question

I enabled to “Uses Bluetooth LE accessories” and “Acts as a Bluetooth LE accessory” in “Background Modes” settings, and these are added in Info.plist.
 and also I allowed my app to access “Bluetooth sharing”.



And my app does scan BLE peripherals well on foreground mode,
 but when it enter background mode, it doesn’t scan anything no more. If it enter foreground mode again, it does scan well again.

More specifically, centralManagerDidUpdateState(_ central: CBCentralManager) always does work well on any modes. but didDiscover doesn't work on background mode.

I want to BLE scanning does work well on any modes and I think I have done everything I can.

Relevant Code

BLEManager.swift

import UIKit

import CoreBluetooth


final class BLEManager: NSObject, CBCentralManagerDelegate, CBPeripheralManagerDelegate {
    static let shared: BLEManager = .init()

    var centralManager: CBCentralManager?
    var peripheralManager: CBPeripheralManager?

    var scannedPeripherals: [CBPeripheral] = .init()
    var confirmedPeripheralStates: [String: CBPeripheralState] = .init()

    override init() {
        super.init()

        self.centralManager = .init(delegate: self, queue: nil)
        self.peripheralManager = .init(delegate: self, queue: nil)
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        switch central.state {
        case .poweredOn:
            self.startScan()
        default:
            central.stopScan()
        }
    }

    func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
        print("[BLE] state: \(peripheral.state.rawValue)")
    }

    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
        self.scannedPeripherals.appendAsUnique(peripheral)

        central.connect(peripheral)

        self.confirm(peripheral)
    }

    func startScan() {
        guard let central = self.centralManager else {
            return
        }

        let isBackgroundMode: Bool = (UIApplication.shared.applicationState == .background)
        let cbuuids: [CBUUID] = self.scannedPeripherals.map { CBUUID(nsuuid: $0.identifier) }

        central.stopScan()
        central.scanForPeripherals(withServices: isBackgroundMode ? cbuuids : nil)
    }

    func confirm(_ peripheral: CBPeripheral) {
        let uuid: String = peripheral.identifier.uuidString

        // Prevent duplicate logging.
        if peripheral.state != self.confirmedPeripheralStates[uuid] {
            self.log(peripheral)
        }

        self.confirmedPeripheralStates[uuid] = peripheral.state
    }

    func log(_ peripheral: CBPeripheral, completion: (() -> Void)? = nil) {
        guard let name = peripheral.name,
              let state = self.getPeripheralStateAsString(peripheral.state) else {
                return
        }

        print("[BLE] \(name) was \(state) on \(self.getApplicationStateAsString())")
    }
}

extension BLEManager {
    func getApplicationStateAsString() -> String {
        switch UIApplication.shared.applicationState {
        case .active:
            return "active"
        case .inactive:
            return "inactive"
        case .background:
            return "background"
        }
    }

    func getPeripheralStateAsString(_ state: CBPeripheralState) -> String? {
        switch state {
        case .disconnected:
            return "disconnected"
        case .connecting:
            return "connecting"
        case .connected:
            return "connected"
        default:
            return nil
        }
    }
}


extension Array where Element: Equatable {
    mutating func appendAsUnique(_ element: Element) {
        if let index = self.index(where: { $0 == element }) {
            self.remove(at: index)
        }

        self.append(element)
    }
}

AppDelegate.swift

func applicationDidEnterBackground(_ application: UIApplication) {
    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.

    BLEManager.shared.startScan()
}

Did I miss anything?