Demo: lazily create CBPeripheralManager only when starting advertising

Previously, PeripheralManager unconditionally instantiated CBPeripheralManager
in init(), causing the system Bluetooth permission prompt on a fresh app launch.

Move creation into startAdvertising() so the prompt only appears when the
user explicitly chooses to use the peripheral advertising feature. This
prevents the demo from appearing to trigger authorization automatically
(via the library or otherwise).

Also update the Start button enable logic to allow activation while the
manager is still uninitialized.

Author: itsniper

Demo/ReliaBLE Demo/ReliaBLE Demo/Peripheral/PeripheralManager.swift

@@ -30,32 +30,47 @@ import SwiftUI
 @Observable class PeripheralManager: NSObject, CBPeripheralManagerDelegate {
     var state: CBManagerState = .unknown
     var isAdvertising: Bool = false
-    private var peripheralManager: CBPeripheralManager!
+    private var peripheralManager: CBPeripheralManager?
     private var peripheralName: String = ""
     private var serviceUUID: CBUUID?
 
-    override init() {
-        super.init()
-        peripheralManager = CBPeripheralManager(delegate: self, queue: nil)
-    }
-
     func startAdvertising(name: String, serviceUUID: CBUUID) {
         self.peripheralName = name
         self.serviceUUID = serviceUUID
-        peripheralManager.removeAllServices()
+
+        if peripheralManager == nil {
+            // Create the manager only at the point the user requests advertising.
+            // This avoids triggering a Bluetooth permission prompt on app launch.
+            // If authorization is notDetermined, this will prompt the user.
+            peripheralManager = CBPeripheralManager(delegate: self, queue: nil)
+            // Actual advertising setup happens in peripheralManagerDidUpdateState once powered on.
+            return
+        }
+
+        guard peripheralManager?.state == .poweredOn else { return }
+        peripheralManager?.removeAllServices()
         let service = CBMutableService(type: serviceUUID, primary: true)
-        peripheralManager.add(service)
+        peripheralManager?.add(service)
     }
 
     func stopAdvertising() {
-        peripheralManager.stopAdvertising()
+        peripheralManager?.stopAdvertising()
         isAdvertising = false
     }
 
     func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
         state = peripheral.state
         if state != .poweredOn {
             isAdvertising = false
+            return
+        }
+
+        // If the user requested advertising before or while the manager was initializing,
+        // proceed with adding the service now that we are powered on.
+        if let uuid = serviceUUID, !isAdvertising {
+            peripheral.removeAllServices()
+            let service = CBMutableService(type: uuid, primary: true)
+            peripheral.add(service)
         }
     }
 
@@ -68,7 +83,7 @@ import SwiftUI
             CBAdvertisementDataLocalNameKey: peripheralName,
             CBAdvertisementDataServiceUUIDsKey: [serviceUUID!]
         ]
-        peripheralManager.startAdvertising(advertisementData)
+        peripheralManager?.startAdvertising(advertisementData)
     }
 
     func peripheralManagerDidStartAdvertising(_ peripheral: CBPeripheralManager, error: Error?) {

Demo/ReliaBLE Demo/ReliaBLE Demo/Peripheral/PeripheralView.swift

@@ -97,7 +97,7 @@ struct PeripheralView: View {
                         peripheralManager.startAdvertising(name: peripheralName, serviceUUID: uuid)
                     }
                 }
-                .disabled(!isValid || peripheralManager.state != .poweredOn || peripheralManager.isAdvertising)
+                .disabled(!isValid || peripheralManager.isAdvertising || (peripheralManager.state != .poweredOn && peripheralManager.state != .unknown))
                 Button("Stop Advertising") {
                     peripheralManager.stopAdvertising()
                 }