Android
ब्लूटूथ कम ऊर्जा

परिचय

BLE डिवाइस ढूँढना

ब्लूटूथ API का उपयोग करने के लिए निम्नलिखित अनुमतियों की आवश्यकता होती है:

android.permission.BLUETOOTH
android.permission.BLUETOOTH_ADMIN

यदि आप Android 6.0 ( API Level 23 ) या उच्चतर वाले उपकरणों को लक्षित कर रहे हैं और स्कैनिंग / विज्ञापन संचालन करना चाहते हैं तो आपको एक स्थान की अनुमति की आवश्यकता होगी:

android.permission.ACCESS_FINE_LOCATION

या

android.permission.ACCESS_COARSE_LOCATION

नोट.- एंड्रॉइड 6.0 (एपीआई स्तर 23) या उच्चतर वाले उपकरणों को भी स्थान सेवा सक्षम होना चाहिए।

एक ब्लूटूथ एडेप्टर ऑब्जेक्ट को स्कैनिंग / विज्ञापन संचालन शुरू करने के लिए आवश्यक है:

BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
bluetoothAdapter = bluetoothManager.getAdapter();

BluetoothLeScanner क्लास का startScan (ScanCallback callback) तरीका स्कैनिंग ऑपरेशन शुरू करने का सबसे बुनियादी तरीका है। परिणाम प्राप्त करने के लिए एक ScanCallback ऑब्जेक्ट आवश्यक है:

bluetoothAdapter.getBluetoothLeScanner().startScan(new ScanCallback() {
     @Override
     public void onScanResult(int callbackType, ScanResult result) {
     super.onScanResult(callbackType, result);
     Log.i(TAG, "Remote device name: " + result.getDevice().getName());
       }
    });

GATT सर्वर से कनेक्ट करना

एक बार जब आप एक वांछित ब्लूटूथडाइस ऑब्जेक्ट खोज लेते हैं, तो आप इसके connectGatt() पद्धति का उपयोग करके इसे कनेक्ट कर सकते हैं जो एक संदर्भ वस्तु के रूप में लेता है, एक बूलियन जो इंगित करता है कि क्या स्वचालित रूप से बीएलई डिवाइस और connectGatt() संदर्भ से कनेक्ट होना है जहां कनेक्शन इवेंट और क्लाइंट ऑपरेशन परिणाम दिया जाएगा:

 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        device.connectGatt(context, false, bluetoothGattCallback, BluetoothDevice.TRANSPORT_AUTO);
    } else {
        device.connectGatt(context, false, bluetoothGattCallback);
    }

कनेक्शन को डिस्कनेक्ट करने वाली घटनाओं को प्राप्त करने के लिए BluetoothGattCallback में onConnectionStateChange को ओवरराइड करें:

    BluetoothGattCallback bluetoothGattCallback =
        new BluetoothGattCallback() {
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status,
            int newState) {
        if (newState == BluetoothProfile.STATE_CONNECTED) {
            Log.i(TAG, "Connected to GATT server.");

        } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
            
            Log.i(TAG, "Disconnected from GATT server.");
        }
    }
   };

विशेषताओं से लेखन और पढ़ना

एक बार जब आप किसी गैट सर्वर से जुड़ जाते हैं, तो आप सर्वर की विशेषताओं से लिखकर और पढ़कर इसके साथ इंटरैक्ट करने वाले होते हैं। ऐसा करने के लिए, आपको पहले यह पता लगाना होगा कि इस सर्वर पर कौन-कौन सी सेवाएँ उपलब्ध हैं और प्रत्येक सेवा में कौन-कौन सी विशेषताएँ उपलब्ध हैं:

 @Override
 public void onConnectionStateChange(BluetoothGatt gatt, int status,
        int newState) {
    if (newState == BluetoothProfile.STATE_CONNECTED) {
        Log.i(TAG, "Connected to GATT server.");
        gatt.discoverServices();

    }
. . .

 @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        if (status == BluetoothGatt.GATT_SUCCESS) {
             List<BluetoothGattService> services = gatt.getServices();
                for (BluetoothGattService service : services) {
                    List<BluetoothGattCharacteristic> characteristics = service.getCharacteristics();
                    for (BluetoothGattCharacteristic characteristic : characteristics) { 
                        ///Once you have a characteristic object, you can perform read/write
                        //operations with it         
                    }
                 }
              }
            }

एक बुनियादी लेखन ऑपरेशन इस प्रकार है:

characteristic.setValue(newValue);
characteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
gatt.writeCharacteristic(characteristic);

जब लिखने की प्रक्रिया समाप्त हो गया है, onCharacteristicWrite अपने की विधि BluetoothGattCallback बुलाया जाएगा:

    @Override
    public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicWrite(gatt, characteristic, status);
        Log.d(TAG, "Characteristic " + characteristic.getUuid() + " written);
    }

एक बुनियादी लेखन ऑपरेशन इस प्रकार है:

gatt.readCharacteristic(characteristic);

जब लिखने की प्रक्रिया समाप्त हो गया है, onCharacteristicRead अपने की विधि BluetoothGattCallback बुलाया जाएगा:

@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
  super.onCharacteristicRead(gatt, characteristic, status);
  byte[] value = characteristic.getValue();
  }

गैट सर्वर से सूचनाओं की सदस्यता

आप Gatt Server से सूचित करने का अनुरोध कर सकते हैं जब किसी विशेषता का मान बदल दिया गया हो:

gatt.setCharacteristicNotification(characteristic, true);
BluetoothGattDescriptor descriptor = characteristic.getDescriptor(
    UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
mBluetoothGatt.writeDescriptor(descriptor);

सर्वर से सभी सूचनाएं आपके BluetoothGattCallback की onCharacteristicChanged विधि में प्राप्त onCharacteristicChanged :

    @Override
    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        super.onCharacteristicChanged(gatt, characteristic);
        byte[] newValue = characteristic.getValue();
}

विज्ञापन एक BLE डिवाइस

आप पहले कनेक्शन स्थापित करने के बिना सभी पास के उपकरणों के लिए डेटा पैकेज प्रसारित करने के लिए ब्लूटूथ ले विज्ञापन का उपयोग कर सकते हैं। ध्यान रखें कि विज्ञापन डेटा की 31 बाइट्स की एक सख्त सीमा है। अपने डिवाइस को विज्ञापन देना भी पहला कदम है जिससे अन्य उपयोगकर्ता आपसे जुड़ सकते हैं।

चूंकि सभी डिवाइस ब्लूटूथ ले विज्ञापन का समर्थन नहीं करते हैं, इसलिए पहला कदम यह जांचना है कि आपके डिवाइस को समर्थन करने के लिए सभी आवश्यक आवश्यकताएं हैं। बाद में, आप एक BluetoothLeAdvertiser ऑब्जेक्ट को इनिशियलाइज़ कर सकते हैं और इसके साथ, आप विज्ञापन संचालन शुरू कर सकते हैं:

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && bluetoothAdapter.isMultipleAdvertisementSupported())
        {
            BluetoothLeAdvertiser advertiser = bluetoothAdapter.getBluetoothLeAdvertiser();

            AdvertiseData.Builder dataBuilder = new AdvertiseData.Builder();
           //Define a service UUID according to your needs                
           dataBuilder.addServiceUuid(SERVICE_UUID);
            dataBuilder.setIncludeDeviceName(true);


             AdvertiseSettings.Builder settingsBuilder = new AdvertiseSettings.Builder();
             settingsBuilder.setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_POWER);
             settingsBuilder.setTimeout(0);

             //Use the connectable flag if you intend on opening a Gatt Server
             //to allow remote connections to your device.
             settingsBuilder.setConnectable(true);

            AdvertiseCallback advertiseCallback=new AdvertiseCallback() {
            @Override
            public void onStartSuccess(AdvertiseSettings settingsInEffect) {
                super.onStartSuccess(settingsInEffect);
                Log.i(TAG, "onStartSuccess: ");
            }

            @Override
            public void onStartFailure(int errorCode) {
                super.onStartFailure(errorCode);
                Log.e(TAG, "onStartFailure: "+errorCode );
            }
          };
advertising.startAdvertising(settingsBuilder.build(),dataBuilder.build(),advertiseCallback);
        }

Gatt Server का उपयोग करना

आपके डिवाइस को एक परिधीय के रूप में कार्य करने के लिए, पहले आपको एक BluetoothGattServer खोलने की आवश्यकता है और इसे कम से कम एक BluetoothGattService और एक BluetoothGattCharacteristic साथ पॉपुलेट करें:

BluetoothGattServer server=bluetoothManager.openGattServer(context, bluetoothGattServerCallback);

BluetoothGattService service = new BluetoothGattService(SERVICE_UUID, BluetoothGattService.SERVICE_TYPE_PRIMARY);

यह पूरी तरह से लिखने, पढ़ने और सूचनाओं को सूचित करने के साथ एक ब्लूटूथगैटेचरेक्टेरिस्टिक का एक उदाहरण है। अपनी आवश्यकताओं के अनुसार, आप उन अनुमतियों को ठीक करना चाहते हैं जो आप इस विशेषता को देते हैं:

BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(CHARACTERISTIC_UUID,
                    BluetoothGattCharacteristic.PROPERTY_READ | BluetoothGattCharacteristic.PROPERTY_WRITE |
                            BluetoothGattCharacteristic.PROPERTY_NOTIFY,
                    BluetoothGattCharacteristic.PERMISSION_READ | BluetoothGattCharacteristic.PERMISSION_WRITE);

characteristic.addDescriptor(new BluetoothGattDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"), BluetoothGattCharacteristic.PERMISSION_WRITE));

service.addCharacteristic(characteristic);

server.addService(service);

BluetoothGattServerCallback आपके BluetoothGattServer से संबंधित सभी घटनाओं को प्राप्त करने के लिए ज़िम्मेदार है:

BluetoothGattServerCallback bluetoothGattServerCallback= new BluetoothGattServerCallback() {
                @Override
                public void onConnectionStateChange(BluetoothDevice device, int status, int newState) {
                    super.onConnectionStateChange(device, status, newState);
                }

                @Override
                public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset, BluetoothGattCharacteristic characteristic) {
                    super.onCharacteristicReadRequest(device, requestId, offset, characteristic);
                }

                @Override
                public void onCharacteristicWriteRequest(BluetoothDevice device, int requestId, BluetoothGattCharacteristic characteristic, boolean preparedWrite, boolean responseNeeded, int offset, byte[] value) {
                    super.onCharacteristicWriteRequest(device, requestId, characteristic, preparedWrite, responseNeeded, offset, value);
                }

                @Override
                public void onDescriptorReadRequest(BluetoothDevice device, int requestId, int offset, BluetoothGattDescriptor descriptor) {
                    super.onDescriptorReadRequest(device, requestId, offset, descriptor);
                }

                @Override
                public void onDescriptorWriteRequest(BluetoothDevice device, int requestId, BluetoothGattDescriptor descriptor, boolean preparedWrite, boolean responseNeeded, int offset, byte[] value) {
                    super.onDescriptorWriteRequest(device, requestId, descriptor, preparedWrite, responseNeeded, offset, value);
                }

जब भी आपको किसी विशेषता या डिस्क्रिप्टर पर लिखने / पढ़ने के लिए अनुरोध प्राप्त होता है, तो आपको अनुरोध को सफलतापूर्वक पूरा करने के लिए उस पर प्रतिक्रिया भेजनी होगी:

@Override
 public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset, BluetoothGattCharacteristic characteristic) {
    super.onCharacteristicReadRequest(device, requestId, offset, characteristic);
    server.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, YOUR_RESPONSE);
}