BluetoothAdapter — यह क्या है, विधियाँ और Android में Bluetooth प्रबंधन

BluetoothAdapter क्या है: सार और इंस्टेंस प्राप्त करना

BluetoothAdapter Android डिवाइस के भौतिक Bluetooth एडेप्टर का प्रतिनिधित्व करता है। प्रत्येक डिवाइस में ठीक एक एडेप्टर होता है (अपवाद Android Automotive है जिसमें कई Bluetooth चिप्स होते हैं, जो BluetoothManager.getAdapterList() का उपयोग करता है)। BluetoothAdapter रेडियो स्थिति को संपुटित करता है: STATE_OFF (0), STATE_TURNING_ON (1), STATE_ON (2), STATE_TURNING_OFF (3)। स्थिति ACTION_STATE_CHANGED पर BroadcastReceiver के माध्यम से ट्रैक की जाती है।

BluetoothAdapter इंस्टेंस प्राप्त करना Android पर किसी भी BLE एप्लिकेशन का पहला कदम है। अनुशंसित विधि API 18+ से BluetoothManager.getAdapter() के माध्यम से है। विकल्प स्थैतिक विधि BluetoothAdapter.getDefaultAdapter() है, जो API 5 से काम करती है लेकिन कम लचीली है। दोनों विधियाँ null लौटाती हैं यदि डिवाइस में Bluetooth मॉड्यूल नहीं है (केवल Wi-Fi टैबलेट, एमुलेटर)। null जाँच अनिवार्य है: एप्लिकेशन को सही ढंग से बंद होना चाहिए या BLE सुविधाओं को अक्षम करना चाहिए।

// BluetoothAdapter प्राप्त करना (अनुशंसित)
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothManager
import android.content.Context

class BluetoothHelper(context: Context) {

    private val bluetoothAdapter: BluetoothAdapter?

    init {
        // विधि 1: BluetoothManager के माध्यम से (API 18+)
        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE)
                as BluetoothManager?
        bluetoothAdapter = manager?.adapter

        // विधि 2: स्थैतिक विधि के माध्यम से (API 5+)
        // val adapter = BluetoothAdapter.getDefaultAdapter()

        // null जाँच
        if (bluetoothAdapter == null) {
            // डिवाइस Bluetooth का समर्थन नहीं करता
        }
    }

    // Bluetooth स्थिति जाँचें
    fun isBluetoothEnabled(): Boolean {
        return bluetoothAdapter?.isEnabled == true
    }

    // एडेप्टर जानकारी प्राप्त करें
    fun getAdapterInfo(): Map<String, String> {
        return mapOf(
            "name" to (bluetoothAdapter?.name ?: "N/A"),
            "address" to (bluetoothAdapter?.address ?: "N/A"),
            "state" to (bluetoothAdapter?.state?.toString() ?: "N/A"),
            "scanMode" to (bluetoothAdapter?.scanMode?.toString() ?: "N/A")
        )
    }
}

BluetoothHelper क्लास बाद की null जाँच के साथ BluetoothManager के माध्यम से BluetoothAdapter प्राप्त करने का प्रदर्शन करता है। isBluetoothEnabled isEnabled की जाँच करता है — किसी भी BLE संचालन से पहले एक अनिवार्य शर्त। getAdapterInfo डिवाइस का नाम, MAC पता, स्थिति और दृश्यता मोड लौटाता है। महत्वपूर्ण: Android 10+ (API 29+) पर, सिस्टम सेवा एक नकली MAC पता (02:00:00:00:00:00) लौटाती है यदि एप्लिकेशन के पास BLUETOOTH_ADMIN और ACCESS_FINE_LOCATION अनुमतियाँ नहीं हैं।

BluetoothAdapter की मुख्य विधियाँ: enable, disable, getState, getAddress

BluetoothAdapter Bluetooth रेडियो को नियंत्रित करने के लिए विधियाँ प्रदान करता है। enable() और disable() Bluetooth चालू और बंद करते हैं। दोनों विधियों के लिए BLUETOOTH_ADMIN अनुमति आवश्यक है और वे अतुल्यकालिक रूप से निष्पादित होती हैं: enable() कॉल करने के बाद, सिस्टम रेडियो चालू करने की प्रक्रिया शुरू करता है, और स्थिति BluetoothAdapter.ACTION_STATE_CHANGED क्रिया के साथ BroadcastReceiver के माध्यम से ट्रैक की जाती है। Android 10+ पर, enable() और disable() के लिए अतिरिक्त सिस्टम विशेषाधिकार आवश्यक है — सामान्य एप्लिकेशन उपयोगकर्ता संवाद के बिना प्रोग्रामेटिक रूप से Bluetooth नियंत्रित नहीं कर सकते।

getState() एडेप्टर की वर्तमान स्थिति लौटाता है: STATE_OFF (10), STATE_TURNING_ON (11), STATE_ON (12), STATE_TURNING_OFF (13)। getAddress() Bluetooth एडेप्टर का MAC पता लौटाता है। Android 6+ पर, MAC पता अनुरोध करने के लिए ACCESS_FINE_LOCATION (या API 31+ के लिए ACCESS_COARSE_LOCATION) आवश्यक है। Android 10+ पर, getAddress() स्थिर पता 02:00:00:00:00:00 लौटाता है — वास्तविक पता सार्वजनिक API के माध्यम से उपलब्ध नहीं है।

getScanMode() एडेप्टर की दृश्यता मोड निर्धारित करता है: SCAN_MODE_NONE (अदृश्य), SCAN_MODE_CONNECTABLE (कनेक्टेड डिवाइसों के लिए दृश्य), SCAN_MODE_CONNECTABLE_DISCOVERABLE (सभी के लिए दृश्य)। दृश्यता मोड सुरक्षा के लिए समय में सीमित है (आमतौर पर 60–300 सेकंड)। setScanMode() के माध्यम से मोड सेट करने के लिए Android 10+ पर BLUETOOTH_ADMIN और सिस्टम अनुमति आवश्यक है।

डिवाइस स्कैनिंग: startDiscovery और BluetoothLeScanner

BluetoothAdapter दो प्रकार की स्कैनिंग का समर्थन करता है। क्लासिक Bluetooth स्कैनिंग (BR/EDR) startDiscovery() के माध्यम से शुरू होती है — यह फ़ोन और हेडसेट सहित सभी प्रकार के Bluetooth डिवाइसों का पता लगाती है। परिणाम BluetoothDevice.ACTION_FOUND क्रिया के साथ BroadcastReceiver के माध्यम से लौटाए जाते हैं। startDiscovery() 12 सेकंड तक चलता है और cancelDiscovery() कॉल करके रद्द किया जा सकता है। यह विधि BLE के लिए पदावनत है — BluetoothLeScanner का उपयोग करें।

BluetoothAdapter के माध्यम से BLE स्कैनिंग पदावनत विधि startLeScan(LeScanCallback) का उपयोग करती है। API 21 से शुरू करके, Google BluetoothLeScanner का उपयोग करने की अनुशंसा करता है, जो BluetoothAdapter.getBluetoothLeScanner() के माध्यम से प्राप्त होता है। BluetoothLeScanner अधिक लचीला API प्रदान करता है: ScanSettings के माध्यम से स्कैनिंग कॉन्फ़िगरेशन (मोड, कॉलबैक प्रकार, मैच मोड), ScanFilter के माध्यम से फ़िल्टरिंग (सेवा UUID, डिवाइस नाम, MAC पता द्वारा), और पृष्ठभूमि स्कैनिंग के लिए PendingIntent का समर्थन।

// पुरानी (पदावनत) बनाम नई BLE स्कैनिंग API
import android.bluetooth.BluetoothAdapter
import android.bluetooth.le.*

class BLEScanner(private val bluetoothAdapter: BluetoothAdapter?) {

    // पदावनत: startLeScan (API 18+, API 21)
    @Suppress("DEPRECATION")
    fun legacyScan() {
        bluetoothAdapter?.startLeScan { device, rssi, scanRecord ->
            print("Found (LE Scan): $device.name, RSSI: $rssi")
        }
    }

    // नया: BluetoothLeScanner (API 21+)
    fun modernScan() {
        val scanner = bluetoothAdapter?.bluetoothLeScanner
            ?: return

        // स्कैन सेटिंग्स
        val settings = ScanSettings.Builder()
            .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
            .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
            .setMatchMode(ScanSettings.MATCH_MODE_AGGRESSIVE)
            .build()

        // सेवा द्वारा फ़िल्टर करें (हार्ट रेट UUID)
        val filters = listOf(
            ScanFilter.Builder()
                .setServiceUuid(ParcelUuid.fromString("0000180D-0000-1000-8000-00805F9B34FB"))
                .build()
        )

        // स्कैन शुरू करें
        scanner.startScan(filters, settings, object : ScanCallback() {
            override fun onScanResult(callbackType: Int, result: ScanResult) {
                val device = result.device
                val rssi = result.rssi
                print("Found (BLE Scanner): ${device.name}, RSSI: $rssi, address: ${device.address}")
            }

            override fun onScanFailed(errorCode: Int) {
                print("Scan error: $errorCode")
            }
        })
    }
}

BLEScanner क्लास पदावनत startLeScan और आधुनिक BluetoothLeScanner की तुलना करता है। legacyScan में, LeScanCallback को BluetoothDevice, RSSI और कच्चा scanRecord प्राप्त होता है। modernScan में, LOW_LATENCY मोड (अधिकतम खोज गति) के साथ ScanSettings और हार्ट रेट सेवा UUID (0x180D) द्वारा फ़िल्टर करने के लिए ScanFilter का उपयोग किया जाता है। ScanCallback विस्तारित जानकारी वाला ScanResult ऑब्जेक्ट प्रदान करता है: नाम, RSSI, विज्ञापन डेटा, कनेक्शन प्रकार।

BluetoothManager: BluetoothAdapter तक पहुँचने के लिए आधुनिक API

BluetoothManager एक सिस्टम Android सेवा है, जिसे API 18 (Android 4.3) में पेश किया गया, Bluetooth संचालन के प्रबंधन के लिए। API 18 से पहले, BluetoothAdapter प्राप्त करने का एकमात्र तरीका स्थैतिक विधि getDefaultAdapter() था। BluetoothManager प्रदान करता है: adapter — BluetoothAdapter इंस्टेंस, getConnectedDevices() — कनेक्टेड डिवाइसों की सूची, getDevicesMatchingConnectionStates() — स्थिति द्वारा फ़िल्टरिंग। BluetoothManager का उपयोग पुराने APIs पर BluetoothLeScanner प्राप्त करने के लिए भी किया जाता है।

BluetoothManager के लाभ सीधे BluetoothAdapter.getDefaultAdapter() कॉल करने की तुलना में: एप्लिकेशन एक स्थैतिक सिंगलटन पर निर्भर नहीं करता, प्रबंधक संदर्भ (Activity/Application) का सम्मान करता है, जो Android Enterprise के मल्टी-अकाउंट परिदृश्यों के लिए महत्वपूर्ण है। एकाधिक Bluetooth चिप्स वाले Android Automotive पर, BluetoothManager.getAdapterList() सभी उपलब्ध एडेप्टर लौटाता है — BluetoothAdapter.getDefaultAdapter() केवल पहला लौटाता है।

// BLE के लिए BluetoothManager का उपयोग
class BLEConnection(context: Context) {

    private val bluetoothManager: BluetoothManager =
        context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager

    private val adapter: BluetoothAdapter? = bluetoothManager.adapter

    // कनेक्टेड BLE डिवाइसों की सूची प्राप्त करें
    fun getConnectedDevices(): List<BluetoothDevice> {
        return bluetoothManager.getConnectedDevices(
            BluetoothProfile.GATT
        )
    }

    // स्थिति द्वारा डिवाइस फ़िल्टर करें
    fun getDevicesByState(states: IntArray): List<BluetoothDevice> {
        return bluetoothManager.getDevicesMatchingConnectionStates(
            BluetoothProfile.GATT, states
        )
    }

    // डिवाइस पर BLE समर्थन जाँचें
    fun isBLESupported(): Boolean {
        return adapter != null && context.packageManager
            .hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)
    }

    // सिस्टम संवाद के माध्यम से Bluetooth चालू करने का अनुरोध
    fun requestEnableBluetooth(activity: MainActivity) {
        if (adapter?.isEnabled == false) {
            val intent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
            activity.startActivityForResult(intent, REQUEST_ENABLE_BT)
        }
    }

    companion object {
        const val REQUEST_ENABLE_BT = 1001
    }
}

BLEConnection क्लास BluetoothAdapter तक पहुँचने और कनेक्टेड GATT डिवाइसों की सूची प्राप्त करने के लिए BluetoothManager का उपयोग करता है। isBLESupported PackageManager.hasSystemFeature(FEATURE_BLUETOOTH_LE) के माध्यम से BLE रेडियो की जाँच करता है — BLE के बिना Bluetooth Classic वाले डिवाइसों के लिए एक महत्वपूर्ण जाँच। requestEnableBluetooth Bluetooth चालू करने का सिस्टम संवाद दिखाता है (ACTION_REQUEST_ENABLE), जिसके लिए BLUETOOTH_ADMIN अनुमति की आवश्यकता नहीं है — यह सिस्टम एप्लिकेशन के बिना Android 10+ पर Bluetooth चालू करने का एकमात्र कानूनी तरीका है।

BluetoothAdapter के साथ काम करने के लिए Android अनुमतियाँ

अनुमतियाँ BluetoothAdapter के लिए प्रत्येक Android संस्करण के साथ विकसित हुई हैं। Android 6–11 (API 23–30) पर, BLE स्कैनिंग के लिए BLUETOOTH, BLUETOOTH_ADMIN और ACCESS_FINE_LOCATION अनिवार्य हैं। Android 12+ (API 31+) पर, Google ने अनुमतियों को विभाजित किया: ACCESS_FINE_LOCATION को BLUETOOTH_SCAN (स्कैनिंग), BLUETOOTH_CONNECT (कनेक्शन), BLUETOOTH_ADVERTISE (विज्ञापन) से बदल दिया गया। BLE डिवाइस खोज के लिए, BLUETOOTH_SCAN पर्याप्त है, स्थान आवश्यक नहीं है।

अनुमति तालिका Android संस्करण के अनुसार:

Android 12+ पर, सभी Bluetooth अनुमतियाँ रनटाइम अनुमतियाँ हैं — उन्हें ActivityResultContracts.RequestMultiplePermissions के माध्यम से रनटाइम पर अनुरोध किया जाना चाहिए। BLUETOOTH_SCAN और BLUETOOTH_ADVERTISE NEARBY_DEVICES समूह से संबंधित हैं, BLUETOOTH_CONNECT उसी समूह से संबंधित है। BLUETOOTH और BLUETOOTH_ADMIN अनुमतियाँ API < 31 के साथ संगतता के लिए मेनिफेस्ट में रहती हैं, लेकिन API 31+ के लिए उन्हें अनदेखा किया जाता है — Google को नई अनुमतियाँ स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता है।

// Android 12+ पर Bluetooth अनुमतियों का अनुरोध
import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import androidx.core.content.ContextCompat

class PermissionHelper(context: Context) {

    fun getRequiredPermissions(): Array<String> {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            // Android 12+: BLE-
            arrayOf(
                Manifest.permission.BLUETOOTH_SCAN,
                Manifest.permission.BLUETOOTH_CONNECT,
                Manifest.permission.BLUETOOTH_ADVERTISE
            )
        } else {
            // Android 6-11: BLE
            arrayOf(
                Manifest.permission.ACCESS_FINE_LOCATION,
                Manifest.permission.BLUETOOTH,
                Manifest.permission.BLUETOOTH_ADMIN
            )
        }
    }

    // सभी अनुमतियाँ जाँचें
    fun hasPermissions(context: Context): Boolean {
        return getRequiredPermissions().all { permission ->
            ContextCompat.checkSelfPermission(context, permission)
                    == PackageManager.PERMISSION_GRANTED
        }
    }
}

PermissionHelper क्लास API स्तर के आधार पर अनुमतियों का सही सेट लौटाता है। Android 12+ पर, बिना स्थान के BLUETOOTH_SCAN, BLUETOOTH_CONNECT, BLUETOOTH_ADVERTISE का उपयोग किया जाता है। Android 6–11 पर, BLE स्कैनिंग के लिए अभी भी ACCESS_FINE_LOCATION आवश्यक है। डेवलपर को ActivityResultContracts या RxPermissions के माध्यम से अनुमतियों का अनुरोध करते समय दोनों परिदृश्यों पर विचार करना चाहिए।

Kotlin में BluetoothAdapter का पूर्ण उदाहरण

पूर्ण उदाहरण Kotlin में एक BLE एप्लिकेशन का जो BluetoothAdapter का उपयोग करके BLE डिवाइस को स्कैन, कनेक्ट और डेटा पढ़ता है। उदाहरण में अनुमति जाँच, एडेप्टर प्राप्त करना, BluetoothLeScanner के माध्यम से स्कैन करना और BluetoothDevice.connectGatt के माध्यम से कनेक्ट करना शामिल है।

// Kotlin में पूर्ण BLE प्रबंधक
class BLEManager(private val context: Context) {

    private val bluetoothManager: BluetoothManager =
        context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
    private val adapter: BluetoothAdapter? = bluetoothManager.adapter
    private var scanner: BluetoothLeScanner? = adapter?.bluetoothLeScanner
    private var gatt: BluetoothGatt? = null

    // 1. सेवा खोज
    fun canScan(): Boolean {
        return adapter?.isEnabled == true
                && scanner != null
                && PermissionHelper(context).hasPermissions(context)
    }

    // 2. फ़िल्टर के साथ
    fun startScanning(callback: (BluetoothDevice, Int) -> Unit) {
        if (!canScan()) return

        val settings = ScanSettings.Builder()
            .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
            .setReportDelay(0)
            .build()

        scanner?.startScan(null, settings, object : ScanCallback() {
            override fun onScanResult(callbackType: Int, result: ScanResult) {
                callback(result.device, result.rssi)
            }
        })
    }

    // 3. स्कैन बंद करें
    fun stopScanning() {
        scanner?.stopScan(object : ScanCallback() {})
    }

    // 4. BLE डिवाइस से कनेक्ट करें
    fun connectToDevice(device: BluetoothDevice) {
        if (adapter?.isEnabled != true) return

        gatt = device.connectGatt(
            context,
            false,
            object : BluetoothGattCallback() {
                override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
                    if (newState == BluetoothProfile.STATE_CONNECTED) {
                        gatt.discoverServices()
                    }
                }

                override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
                    // सेवाएँ मिलीं, विशेषताएँ पढ़ी जा सकती हैं
                }
            },
            BluetoothDevice.TRANSPORT_LE
        )
    }

    // 5. संसाधन मुक्त करें
    fun disconnect() {
        gatt?.disconnect()
        gatt?.close()
        gatt = null
    }
}

BLEManager क्लास Android पर पूर्ण BLE चक्र को एकीकृत करता है: एडेप्टर और अनुमतियों की जाँच (canScan), ScanSettings के साथ BluetoothLeScanner के माध्यम से स्कैन करना (startScanning), TRANSPORT_LE के साथ BluetoothDevice.connectGatt के माध्यम से कनेक्ट करना (connectToDevice), और संसाधनों को मुक्त करना (disconnect)। सभी BLE संचालन UI थ्रेड पर निष्पादित होते हैं — Android मुख्य थ्रेड पर BluetoothGattCallback कॉलबैक कॉल करता है। प्रदर्शन-महत्वपूर्ण BLE कार्यों के लिए, GATT संचालन को पृष्ठभूमि HandlerThread में स्थानांतरित करने की अनुशंसा की जाती है।