使用Swift开发无需定位的同款App附近iPhone检测功能可行吗？

Absolutely possible! You don’t need to rely on location services to spot nearby iPhones running your app—Apple provides native frameworks that let you detect devices over Bluetooth or local Wi-Fi, no GPS needed. Let’s break down the two most reliable approaches:

1. Core Bluetooth (BLE) #

Bluetooth Low Energy (BLE) is perfect for this use case because it’s designed for low-power, short-range device discovery. Here’s how it works:

• Your app acts as a peripheral on one device, broadcasting a custom service UUID that’s unique to your app.
• On other devices, your app acts as a central, scanning specifically for that UUID. Any device broadcasting the matching UUID is another instance of your app.

Key Details: #

• You don’t need location permissions for this—iOS only requires Bluetooth permissions (add NSBluetoothAlwaysUsageDescription or NSBluetoothPeripheralUsageDescription to your Info.plist to explain why you need Bluetooth access).
• For background detection, you can enable the "Bluetooth LE Accessories" background mode in your app’s capabilities.

Quick Code Snippet (Broadcasting as Peripheral): #

import CoreBluetooth

class PeripheralManager: NSObject, CBPeripheralManagerDelegate {
    private var peripheralManager: CBPeripheralManager!
    private let appServiceUUID = CBUUID(string: "YOUR_CUSTOM_UUID")

    override init() {
        super.init()
        peripheralManager = CBPeripheralManager(delegate: self, queue: nil)
    }

    func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
        if peripheral.state == .poweredOn {
            let service = CBMutableService(type: appServiceUUID, primary: true)
            peripheralManager.add(service)
            peripheralManager.startAdvertising([CBAdvertisementDataServiceUUIDsKey: [appServiceUUID]])
        }
    }
}

Quick Code Snippet (Scanning as Central): #

import CoreBluetooth

class CentralManager: NSObject, CBCentralManagerDelegate {
    private var centralManager: CBCentralManager!
    private let appServiceUUID = CBUUID(string: "YOUR_CUSTOM_UUID")

    override init() {
        super.init()
        centralManager = CBCentralManager(delegate: self, queue: nil)
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            centralManager.scanForPeripherals(withServices: [appServiceUUID], options: nil)
        }
    }

    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
        // Found a device running your app!
        print("Detected nearby app instance: \(peripheral.name ?? "Unknown Device")")
    }
}

2. Multipeer Connectivity Framework #

If you want a more high-level solution that handles both Bluetooth and Wi-Fi direct connections automatically, the Multipeer Connectivity framework is ideal. It’s built specifically for peer-to-peer communication between nearby devices, and it abstracts away most of the low-level details.

How It Works: #

• Use MCNearbyServiceAdvertiser to broadcast your app’s presence with a custom service type (e.g., my-app-service).
• Use MCNearbyServiceBrowser to scan for devices advertising the same service type.

Key Details: #

• No location permissions needed. You will need to add NSLocalNetworkUsageDescription to your Info.plist if you want to support Wi-Fi-based discovery (this lets iOS know why you need access to the local network).
• Background discovery is supported by enabling the "Multipeer Connectivity" background mode.

Quick Code Snippet (Advertising): #

import MultipeerConnectivity

class Advertiser: NSObject, MCNearbyServiceAdvertiserDelegate {
    private var advertiser: MCNearbyServiceAdvertiser!
    private let myPeerID = MCPeerID(displayName: UIDevice.current.name)
    private let serviceType = "my-app-service"

    override init() {
        super.init()
        advertiser = MCNearbyServiceAdvertiser(peer: myPeerID, discoveryInfo: nil, serviceType: serviceType)
        advertiser.delegate = self
        advertiser.startAdvertisingPeer()
    }

    func advertiser(_ advertiser: MCNearbyServiceAdvertiser, didReceiveInvitationFromPeer peerID: MCPeerID, withContext context: Data?, invitationHandler: @escaping (Bool, MCSession?) -> Void) {
        // Accept the invitation if you want to connect
        invitationHandler(true, nil)
    }
}

Quick Code Snippet (Browsing): #

import MultipeerConnectivity

class Browser: NSObject, MCNearbyServiceBrowserDelegate {
    private var browser: MCNearbyServiceBrowser!
    private let myPeerID = MCPeerID(displayName: UIDevice.current.name)
    private let serviceType = "my-app-service"

    override init() {
        super.init()
        browser = MCNearbyServiceBrowser(peer: myPeerID, serviceType: serviceType)
        browser.delegate = self
        browser.startBrowsingForPeers()
    }

    func browser(_ browser: MCNearbyServiceBrowser, foundPeer peerID: MCPeerID, withDiscoveryInfo info: [String : String]?) {
        // Found a nearby app instance!
        print("Detected peer: \(peerID.displayName)")
    }

    func browser(_ browser: MCNearbyServiceBrowser, lostPeer peerID: MCPeerID) {
        // Peer went out of range or closed the app
        print("Lost peer: \(peerID.displayName)")
    }
}

Key Considerations #

• Device Settings: Users must have Bluetooth enabled (for both methods) and Wi-Fi enabled (if using Multipeer’s Wi-Fi discovery).
• Background Mode: If you want detection to work when the app is in the background, make sure to enable the appropriate background modes in your app’s capabilities (Bluetooth LE Accessories for Core Bluetooth, Multipeer Connectivity for the Multipeer framework).
• UUID/Service Type Uniqueness: Use a unique UUID (for Core Bluetooth) or service type (for Multipeer) to avoid detecting other apps that might use similar identifiers.

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