दो डिवाइसों के बीच कनेक्शन बनाने के लिए, आपको सर्वर-साइड और क्लाइंट-साइड, दोनों मैकेनिज़्म लागू करने होंगे. ऐसा इसलिए, क्योंकि एक डिवाइस को सर्वर सॉकेट खोलना होगा और दूसरे डिवाइस को सर्वर डिवाइस के मैक पते का इस्तेमाल करके कनेक्शन शुरू करना होगा. सर्वर डिवाइस और क्लाइंट डिवाइस, दोनों को ज़रूरी BluetoothSocket अलग-अलग तरीकों से मिलता है. इनकमिंग कनेक्शन स्वीकार होने पर, सर्वर को सॉकेट की जानकारी मिलती है. जब क्लाइंट, सर्वर के लिए आरएफ़सीओएमएम चैनल खोलता है, तब वह सॉकेट की जानकारी देता है.
सर्वर और क्लाइंट को एक-दूसरे से कनेक्ट तब माना जाता है, जब दोनों के पास एक ही RFCOMM चैनल पर कनेक्ट किया गया BluetoothSocket हो. इस समय, हर डिवाइस इनपुट और आउटपुट स्ट्रीम हासिल कर सकता है. साथ ही, डेटा ट्रांसफ़र शुरू हो सकता है. इसके बारे में, ब्लूटूथ डेटा ट्रांसफ़र करने वाले सेक्शन में बताया गया है. इस सेक्शन में, दो डिवाइसों के बीच कनेक्शन शुरू करने का तरीका बताया गया है.
ब्लूटूथ डिवाइसों को ढूंढने से पहले, पक्का करें कि आपके पास ब्लूटूथ से जुड़ी ज़रूरी अनुमतियां हों और आपने ब्लूटूथ के लिए अपना ऐप्लिकेशन सेट अप किया हो.
कनेक्ट करने की तकनीकें
लागू करने की एक तकनीक यह है कि हर डिवाइस को सर्वर के तौर पर अपने-आप तैयार किया जाए, ताकि हर डिवाइस में एक सर्वर सॉकेट खुला हो और कनेक्शन के लिए सुन रहा हो. इस मामले में, दोनों में से कोई भी डिवाइस दूसरे डिवाइस से कनेक्शन शुरू कर सकता है और क्लाइंट बन सकता है. इसके अलावा, एक डिवाइस कनेक्शन को होस्ट कर सकता है और ज़रूरत पड़ने पर सर्वर सॉकेट खोल सकता है. इसके बाद, दूसरा डिवाइस कनेक्शन शुरू करता है.
सर्वर के तौर पर कनेक्ट करना
जब आपको दो डिवाइसों को कनेक्ट करना हो, तो एक डिवाइस को सर्वर के तौर पर काम करना होगा. इसके लिए, उसे एक
खुला हुआ
BluetoothServerSocket रखना होगा.
सर्वर सॉकेट का मकसद, इनकमिंग कनेक्शन के अनुरोधों को सुनना और अनुरोध स्वीकार होने के बाद, कनेक्ट किया गया BluetoothSocket उपलब्ध कराना है. BluetoothServerSocket से BluetoothSocket मिलने के बाद, BluetoothServerSocket को खारिज किया जा सकता है और किया जाना चाहिए. हालांकि, ऐसा तब ही करें, जब आपको डिवाइस को ज़्यादा कनेक्शन स्वीकार करने की अनुमति न देनी हो.
सर्वर सॉकेट सेट अप करने और कनेक्शन स्वीकार करने के लिए, यह तरीका अपनाएं:
BluetoothServerSocketपाने के लिए,listenUsingRfcommWithServiceRecord(String, UUID)पर कॉल करें.स्ट्रिंग, आपकी सेवा का एक ऐसा नाम है जिससे उसकी पहचान की जा सकती है. सिस्टम, इस नाम को डिवाइस पर मौजूद सर्विस डिस्कवरी प्रोटोकॉल (एसडीपी) डेटाबेस की नई एंट्री में अपने-आप लिखता है. यह नाम कुछ भी हो सकता है. जैसे, आपके ऐप्लिकेशन का नाम. यूनिवर्सली यूनीक आइडेंटिफ़ायर (यूयूआईडी) को भी एसडीपी एंट्री में शामिल किया जाता है. साथ ही, यह क्लाइंट डिवाइस के साथ कनेक्शन के समझौते का आधार बनता है. इसका मतलब है कि जब क्लाइंट इस डिवाइस से कनेक्ट करने की कोशिश करता है, तो उसमें एक यूयूआईडी होता है. यह यूयूआईडी, उस सेवा की खास तौर पर पहचान करता है जिससे क्लाइंट को कनेक्ट करना है. कनेक्शन स्वीकार करने के लिए, ये UUID मैच होने चाहिए.
यूयूआईडी, स्ट्रिंग आईडी के लिए स्टैंडर्ड 128-बिट फ़ॉर्मैट है. इसका इस्तेमाल, जानकारी की खास तौर पर पहचान करने के लिए किया जाता है. यूयूआईडी का इस्तेमाल, ऐसी जानकारी की पहचान करने के लिए किया जाता है जो किसी सिस्टम या नेटवर्क में यूनीक होनी चाहिए. ऐसा इसलिए, क्योंकि यूयूआईडी के दोहराए जाने की संभावना न के बराबर होती है. इसे किसी केंद्रीय संस्था की मदद के बिना, अपने-आप जनरेट किया जाता है. इस मामले में, इसका इस्तेमाल आपके ऐप्लिकेशन की ब्लूटूथ सेवा की खास तौर पर पहचान करने के लिए किया जाता है. अपने ऐप्लिकेशन के साथ इस्तेमाल करने के लिए यूयूआईडी पाने के लिए, वेब पर मौजूद कई रैंडम
UUIDजनरेटर में से किसी एक का इस्तेमाल किया जा सकता है. इसके बाद,fromString(String)की मदद से यूयूआईडी को शुरू किया जा सकता है.कनेक्शन के अनुरोधों को सुनने के लिए,
accept()को कॉल करें.यह एक ब्लॉकिंग कॉल है. यह तब वापस आता है, जब कनेक्शन स्वीकार कर लिया जाता है या कोई अपवाद होता है. कनेक्शन को सिर्फ़ तब स्वीकार किया जाता है, जब किसी रिमोट डिवाइस ने कनेक्शन का अनुरोध भेजा हो. साथ ही, उस अनुरोध में ऐसा यूयूआईडी शामिल हो जो इस लिसनिंग सर्वर सॉकेट के साथ रजिस्टर किए गए यूयूआईडी से मेल खाता हो. कनेक्शन हो जाने पर,
accept()कनेक्ट किए गएBluetoothSocketको दिखाता है.अगर आपको और कनेक्शन नहीं चाहिए, तो
close()पर कॉल करें.यह तरीका, सर्वर सॉकेट और उसके सभी संसाधनों को रिलीज़ करता है. हालांकि, यह
accept()से मिले कनेक्ट किए गएBluetoothSocketको बंद नहीं करता. टीसीपी/आईपी के उलट, आरएफ़सीओएमएम हर चैनल पर एक बार में सिर्फ़ एक कनेक्टेड क्लाइंट को अनुमति देता है. इसलिए, ज़्यादातर मामलों में कनेक्टेड सॉकेट को स्वीकार करने के तुरंत बाद,BluetoothServerSocketपरclose()को कॉल करना सही होता है.
accept() कॉल एक ब्लॉकिंग कॉल है. इसलिए, इसे मुख्य गतिविधि के यूज़र इंटरफ़ेस (यूआई) थ्रेड में लागू न करें. इसे किसी दूसरे थ्रेड में लागू करने से यह पक्का होता है कि आपका ऐप्लिकेशन, उपयोगकर्ता के अन्य इंटरैक्शन का जवाब दे सकता है. आम तौर पर, BluetoothServerSocket या BluetoothSocket से जुड़े सभी काम, आपके ऐप्लिकेशन से मैनेज किए जाने वाले नए थ्रेड में करना सही रहता है. accept() जैसे ब्लॉक किए गए कॉल को रद्द करने के लिए, किसी दूसरे थ्रेड से BluetoothServerSocket या BluetoothSocket पर close() को कॉल करें. ध्यान दें कि BluetoothServerSocket या BluetoothSocket पर मौजूद सभी तरीके थ्रेड-सेफ़ होते हैं.
उदाहरण
यहां सर्वर कॉम्पोनेंट के लिए एक आसान थ्रेड दिया गया है, जो इनकमिंग कनेक्शन स्वीकार करता है:
Kotlin
private inner class AcceptThread : Thread() { private val mmServerSocket: BluetoothServerSocket? by lazy(LazyThreadSafetyMode.NONE) { bluetoothAdapter?.listenUsingInsecureRfcommWithServiceRecord(NAME, MY_UUID) } override fun run() { // Keep listening until exception occurs or a socket is returned. var shouldLoop = true while (shouldLoop) { val socket: BluetoothSocket? = try { mmServerSocket?.accept() } catch (e: IOException) { Log.e(TAG, "Socket's accept() method failed", e) shouldLoop = false null } socket?.also { manageMyConnectedSocket(it) mmServerSocket?.close() shouldLoop = false } } } // Closes the connect socket and causes the thread to finish. fun cancel() { try { mmServerSocket?.close() } catch (e: IOException) { Log.e(TAG, "Could not close the connect socket", e) } } }
Java
private class AcceptThread extends Thread { private final BluetoothServerSocket mmServerSocket; public AcceptThread() { // Use a temporary object that is later assigned to mmServerSocket // because mmServerSocket is final. BluetoothServerSocket tmp = null; try { // MY_UUID is the app's UUID string, also used by the client code. tmp = bluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID); } catch (IOException e) { Log.e(TAG, "Socket's listen() method failed", e); } mmServerSocket = tmp; } public void run() { BluetoothSocket socket = null; // Keep listening until exception occurs or a socket is returned. while (true) { try { socket = mmServerSocket.accept(); } catch (IOException e) { Log.e(TAG, "Socket's accept() method failed", e); break; } if (socket != null) { // A connection was accepted. Perform work associated with // the connection in a separate thread. manageMyConnectedSocket(socket); mmServerSocket.close(); break; } } } // Closes the connect socket and causes the thread to finish. public void cancel() { try { mmServerSocket.close(); } catch (IOException e) { Log.e(TAG, "Could not close the connect socket", e); } } }
इस उदाहरण में, सिर्फ़ एक इनकमिंग कनेक्शन की ज़रूरत है. इसलिए, कनेक्शन स्वीकार होने और BluetoothSocket मिलने के बाद, ऐप्लिकेशन मिले हुए BluetoothSocket को एक अलग थ्रेड में पास करता है, BluetoothServerSocket को बंद करता है, और लूप से बाहर निकल जाता है.
ध्यान दें कि जब accept(), BluetoothSocket दिखाता है, तब सॉकेट पहले से ही कनेक्ट होता है. इसलिए, आपको connect() को कॉल नहीं करना चाहिए, जैसा कि क्लाइंट साइड से किया जाता है.
ऐप्लिकेशन के लिए खास तौर पर बनाए गए manageMyConnectedSocket() तरीके को, डेटा ट्रांसफ़र करने के लिए थ्रेड शुरू करने के मकसद से डिज़ाइन किया गया है. इस बारे में ब्लूटूथ डेटा ट्रांसफ़र करना विषय में बताया गया है.
आम तौर पर, इनकमिंग कनेक्शन के लिए सुनने की प्रोसेस पूरी होने के बाद, आपको BluetoothServerSocket को बंद कर देना चाहिए. इस उदाहरण में, BluetoothSocket मिलते ही close() को कॉल किया जाता है. आपको अपने थ्रेड में एक सार्वजनिक तरीका भी उपलब्ध कराना पड़ सकता है. इससे निजी BluetoothSocket को बंद किया जा सकता है. ऐसा तब किया जा सकता है, जब आपको उस सर्वर सॉकेट पर सुनना बंद करना हो.
क्लाइंट के तौर पर कनेक्ट करना
किसी ऐसे रिमोट डिवाइस से कनेक्शन शुरू करने के लिए जो खुले हुए सर्वर सॉकेट पर कनेक्शन स्वीकार कर रहा है, आपको सबसे पहले एक BluetoothDevice ऑब्जेक्ट पाना होगा. यह ऑब्जेक्ट, रिमोट डिवाइस को दिखाता है. BluetoothDevice बनाने का तरीका जानने के लिए, ब्लूटूथ डिवाइस ढूंढना लेख पढ़ें. इसके बाद, आपको BluetoothDevice का इस्तेमाल करके BluetoothSocket हासिल करना होगा और कनेक्शन शुरू करना होगा.
बुनियादी तरीका इस तरह है:
BluetoothDeviceका इस्तेमाल करके,createRfcommSocketToServiceRecord(UUID)पर कॉल करकेBluetoothSocketपाएं.यह तरीका,
BluetoothSocketऑब्जेक्ट को शुरू करता है. इससे क्लाइंट,BluetoothDeviceसे कनेक्ट कर पाता है. यहां पास किया गया यूयूआईडी, उस यूयूआईडी से मैच होना चाहिए जिसका इस्तेमाल सर्वर डिवाइस नेBluetoothServerSocketखोलने के लिए,listenUsingRfcommWithServiceRecord(String, UUID)को कॉल करते समय किया था. मैच होने वाले यूयूआईडी का इस्तेमाल करने के लिए, यूयूआईडी स्ट्रिंग को अपने ऐप्लिकेशन में हार्ड-कोड करें. इसके बाद, सर्वर और क्लाइंट कोड, दोनों से इसे रेफ़र करें.कनेक्शन शुरू करने के लिए,
connect()को कॉल करें. ध्यान दें कि यह तरीका, ब्लॉक करने वाला कॉल है.जब कोई क्लाइंट इस तरीके को कॉल करता है, तो सिस्टम एसडीपी लुकअप करता है. इससे, मैच होने वाले यूयूआईडी वाले रिमोट डिवाइस का पता लगाया जाता है. अगर लुकअप सफल होता है और रिमोट डिवाइस कनेक्शन को स्वीकार करता है, तो वह कनेक्शन के दौरान इस्तेमाल करने के लिए RFCOMM चैनल शेयर करता है. साथ ही,
connect()तरीका वापस आ जाता है. अगर कनेक्शन नहीं हो पाता है याconnect()तरीके का समय खत्म हो जाता है (करीब 12 सेकंड के बाद), तो यह तरीकाIOExceptionदिखाता है.
connect() एक ब्लॉकिंग कॉल है. इसलिए, आपको कनेक्शन की यह प्रोसेस हमेशा मुख्य गतिविधि (यूज़र इंटरफ़ेस) थ्रेड से अलग थ्रेड में पूरी करनी चाहिए.
उदाहरण
यहां क्लाइंट थ्रेड का एक बुनियादी उदाहरण दिया गया है, जो ब्लूटूथ कनेक्शन शुरू करता है:
Kotlin
private inner class ConnectThread(device: BluetoothDevice) : Thread() { private val mmSocket: BluetoothSocket? by lazy(LazyThreadSafetyMode.NONE) { device.createRfcommSocketToServiceRecord(MY_UUID) } public override fun run() { // Cancel discovery because it otherwise slows down the connection. bluetoothAdapter?.cancelDiscovery() mmSocket?.let { socket -> // Connect to the remote device through the socket. This call blocks // until it succeeds or throws an exception. socket.connect() // The connection attempt succeeded. Perform work associated with // the connection in a separate thread. manageMyConnectedSocket(socket) } } // Closes the client socket and causes the thread to finish. fun cancel() { try { mmSocket?.close() } catch (e: IOException) { Log.e(TAG, "Could not close the client socket", e) } } }
Java
private class ConnectThread extends Thread { private final BluetoothSocket mmSocket; private final BluetoothDevice mmDevice; public ConnectThread(BluetoothDevice device) { // Use a temporary object that is later assigned to mmSocket // because mmSocket is final. BluetoothSocket tmp = null; mmDevice = device; try { // Get a BluetoothSocket to connect with the given BluetoothDevice. // MY_UUID is the app's UUID string, also used in the server code. tmp = device.createRfcommSocketToServiceRecord(MY_UUID); } catch (IOException e) { Log.e(TAG, "Socket's create() method failed", e); } mmSocket = tmp; } public void run() { // Cancel discovery because it otherwise slows down the connection. bluetoothAdapter.cancelDiscovery(); try { // Connect to the remote device through the socket. This call blocks // until it succeeds or throws an exception. mmSocket.connect(); } catch (IOException connectException) { // Unable to connect; close the socket and return. try { mmSocket.close(); } catch (IOException closeException) { Log.e(TAG, "Could not close the client socket", closeException); } return; } // The connection attempt succeeded. Perform work associated with // the connection in a separate thread. manageMyConnectedSocket(mmSocket); } // Closes the client socket and causes the thread to finish. public void cancel() { try { mmSocket.close(); } catch (IOException e) { Log.e(TAG, "Could not close the client socket", e); } } }
ध्यान दें कि इस स्निपेट में, कनेक्शन की कोशिश होने से पहले cancelDiscovery() को कॉल किया जाता है. आपको हमेशा connect() से पहले cancelDiscovery() को कॉल करना चाहिए. खास तौर पर इसलिए, क्योंकि cancelDiscovery() इस बात पर ध्यान दिए बिना सफल होता है कि डिवाइस की खोज फ़िलहाल जारी है या नहीं. अगर आपके ऐप्लिकेशन को यह पता लगाना है कि डिवाइस खोजने की प्रोसेस चल रही है या नहीं, तो isDiscovering() का इस्तेमाल करके इसकी जांच की जा सकती है.
ऐप्लिकेशन के लिए खास तौर पर बनाए गए manageMyConnectedSocket() तरीके को डेटा ट्रांसफ़र करने के लिए थ्रेड शुरू करने के लिए डिज़ाइन किया गया है. इस बारे में ब्लूटूथ डेटा ट्रांसफ़र करने वाले सेक्शन में बताया गया है.
BluetoothSocket का इस्तेमाल करने के बाद, हमेशा close() को कॉल करें. ऐसा करने से, कनेक्ट किया गया सॉकेट तुरंत बंद हो जाता है और उससे जुड़े सभी इंटरनल रिसॉर्स रिलीज़ हो जाते हैं.