Merge branch 'master' into patch-2

libraries/BluetoothSerial/src/BluetoothSerial.cpp

@@ -452,6 +452,57 @@ static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
                         }
                         break;
 
+                    case ESP_BT_GAP_DEV_PROP_BDNAME: // Enum 1 - Bluetooth device name, value type is int8_t []
+                        peer_bdname_len = param->disc_res.prop[i].len;
+                        memcpy(peer_bdname, param->disc_res.prop[i].val, peer_bdname_len);
+                        peer_bdname_len--; // len includes 0 terminator
+                        log_v("ESP_BT_GAP_DISC_RES_EVT : BDNAME :  %s : %d", peer_bdname, peer_bdname_len);
+                        if (strlen(_remote_name) == peer_bdname_len
+                            && strncmp(peer_bdname, _remote_name, peer_bdname_len) == 0) {
+                            log_i("ESP_BT_GAP_DISC_RES_EVT : SPP_START_DISCOVERY_BDNAME : %s", peer_bdname);
+                            _isRemoteAddressSet = true;
+                            memcpy(_peer_bd_addr, param->disc_res.bda, ESP_BD_ADDR_LEN);
+                            esp_bt_gap_cancel_discovery();
+                            esp_spp_start_discovery(_peer_bd_addr);
+                        }
+                        break;
+
+                    case ESP_BT_GAP_DEV_PROP_COD: // Enum 2 - Class of Device, value type is uint32_t
+                        if (param->disc_res.prop[i].len <= sizeof(int)) {
+                            uint32_t cod = 0;
+                            memcpy(&cod, param->disc_res.prop[i].val, param->disc_res.prop[i].len);
+                            advertisedDevice.setCOD(cod);
+                            log_d("ESP_BT_GAP_DEV_PROP_COD 0x%x", cod);
+                        } else {
+                            log_d("ESP_BT_GAP_DEV_PROP_COD invalid COD: Value size larger than integer");
+                        }
+                        break;
+
+                    case ESP_BT_GAP_DEV_PROP_RSSI: // Enum 3 - Received Signal strength Indication, value type is int8_t, ranging from -128 to 127
+                        if (param->disc_res.prop[i].len <= sizeof(int)) {
+                            uint8_t rssi = 0;
+                            memcpy(&rssi, param->disc_res.prop[i].val, param->disc_res.prop[i].len);
+                            log_d("ESP_BT_GAP_DEV_PROP_RSSI %d", rssi);
+                            advertisedDevice.setRSSI(rssi);
+                        } else {
+                            log_d("ESP_BT_GAP_DEV_PROP_RSSI invalid RSSI: Value size larger than integer");
+                        }
+                        break;
+
+                    case ESP_BT_GAP_DEV_PROP_EIR: // Enum 4 - Extended Inquiry Response, value type is uint8_t []
+                        if (get_name_from_eir((uint8_t*)param->disc_res.prop[i].val, peer_bdname, &peer_bdname_len)) {
+                            log_i("ESP_BT_GAP_DISC_RES_EVT : EIR : %s : %d", peer_bdname, peer_bdname_len);
+                            if (strlen(_remote_name) == peer_bdname_len
+                                && strncmp(peer_bdname, _remote_name, peer_bdname_len) == 0) {
+                                log_v("ESP_BT_GAP_DISC_RES_EVT : SPP_START_DISCOVERY_EIR : %s", peer_bdname, peer_bdname_len);
+                                _isRemoteAddressSet = true;
+                                memcpy(_peer_bd_addr, param->disc_res.bda, ESP_BD_ADDR_LEN);
+                                esp_bt_gap_cancel_discovery();
+                                esp_spp_start_discovery(_peer_bd_addr);
+                            }
+                        }
+                        break;
+
                     default:
                         log_i("ESP_BT_GAP_DISC_RES_EVT unknown property [%d]:type:%d", i, param->disc_res.prop[i].type);
                         break;
@@ -883,6 +934,7 @@ void BluetoothSerial::memrelease()
     esp_bt_mem_release(ESP_BT_MODE_BTDM);
 }
 
+#ifdef CONFIG_BT_SSP_ENABLED
 void BluetoothSerial::onConfirmRequest(ConfirmRequestCb cb)
 {
     confirm_request_callback = cb;
@@ -928,27 +980,21 @@ void BluetoothSerial::enableSSP() {
     _IO_CAP_OUTPUT = true;
 }
 
-/**
- * Set default parameters for Legacy Pairing
- * Use fixed pin code
- */
-bool BluetoothSerial::setPin(const char *pin) {
-    log_i("pin: %s", pin);
-    bool isEmpty =  !(pin  && *pin);
-    if (isEmpty && !_isPinSet) {
-        return true; // nothing to do
-    } else if (!isEmpty){
-        _pin_len = strlen(pin);
-        memcpy(_pin_code, pin, _pin_len);
-    } else {
-        _pin_len = 0; // resetting pin to none (default)
-    }
-    _pin_code[_pin_len] = 0;
-    _isPinSet = true;
-    if (isReady(false, READY_TIMEOUT)) {
-        btSetPin();
-    }
-    return true;
+// Enable Simple Secure Pairing (using generated PIN)
+// This must be called before calling begin, otherwise has no effect!
+// Behavior description:
+// When both Input and Output are false only the other device authenticates pairing without any pin.
+// When Output is true and Input is false only the other device authenticates pairing without any pin.
+// When both Input and Output are true both devices display randomly generated code and if they match authenticate pairing on both devices
+//   - This must be implemented by registering callback via onConfirmRequest() and in this callback request user input and call confirmReply(true); if the authenticated
+//      otherwise call `confirmReply(false)` to reject the pairing.
+// When Input is true and Output is false User will be required to input the passkey to the ESP32 device to authenticate.
+//   - This must be implemented by registering callback via onKeyRequest() and in this callback the entered passkey will be responded via respondPasskey(passkey);
+void BluetoothSerial::enableSSP(bool inputCpability, bool outputCapability) {
+    log_i("Enabling SSP: input capability=%d; output capability=%d", inputCpability, outputCapability);
+    _enableSSP = true;
+    _IO_CAP_INPUT = inputCpability;
+    _IO_CAP_OUTPUT = outputCapability;
 }
 
 // Disable Simple Secure Pairing (using generated PIN)