Der erste Schritt bei der Interaktion mit einem BLE-Gerät besteht darin, eine Verbindung zu diesem Gerät herzustellen. Mehr
eine Verbindung zum GATT-Server
auf dem Gerät herstellen. Verbindung zu einem GATT herstellen
Server auf einem BLE-Gerät verwenden, nutzen Sie
connectGatt()
. Diese Methode verwendet drei Parameter: a
Context-Objekt, autoConnect (ein boolescher Wert
gibt an, ob automatisch eine Verbindung zum BLE-Gerät hergestellt werden soll, sobald
verfügbar wird) und ein Verweis auf eine
BluetoothGattCallback:
Kotlin
var bluetoothGatt: BluetoothGatt? = null ... bluetoothGatt = device.connectGatt(this, false, gattCallback)
Java
bluetoothGatt = device.connectGatt(this, false, gattCallback);
Dadurch wird eine Verbindung zum GATT-Server hergestellt, der vom BLE-Gerät gehostet wird, und eine Fehlermeldung
BluetoothGatt-Instanz, die
die Sie dann für die Durchführung
von GATT-Client-Operationen verwenden können. Der Anrufer (Android-App)
ist der GATT-Kunde. Die
BluetoothGattCallback wird verwendet, um Ergebnisse an den Client zu liefern, z. B.
Verbindungsstatus sowie alle weiteren GATT-Clientvorgänge.
gebundenen Dienst einrichten
Im folgenden Beispiel stellt die BLE-App eine Aktivität
(DeviceControlActivity), um eine Verbindung zu Bluetooth-Geräten herzustellen, Gerätedaten anzuzeigen,
und die vom Gerät unterstützten GATT-Dienste und -Eigenschaften aufrufen können. Basierend auf
auf Nutzereingabe reagiert, kommuniziert diese Aktivität mit einem
Service hat den Namen BluetoothLeService, mit dem
interagiert über die BLE API mit dem BLE-Gerät. Die Kommunikation ist
die mit einem gebundenen Dienst ausgeführt werden,
die Aktivität, um eine Verbindung zu BluetoothLeService herzustellen und Funktionen aufzurufen,
eine Verbindung zu den Geräten herstellen. Für BluetoothLeService ist ein
Binder-Implementierung, die Zugriff auf
den Dienst für die Aktivität.
Kotlin
class BluetoothLeService : Service() {
private val binder = LocalBinder()
override fun onBind(intent: Intent): IBinder? {
return binder
}
inner class LocalBinder : Binder() {
fun getService() : BluetoothLeService {
return this@BluetoothLeService
}
}
}
Java
class BluetoothLeService extends Service {
private Binder binder = new LocalBinder();
@Nullable
@Override
public IBinder onBind(Intent intent) {
return binder;
}
class LocalBinder extends Binder {
public BluetoothLeService getService() {
return BluetoothLeService.this;
}
}
}
Die Aktivität kann den Dienst starten mit
bindService(),
übergeben eine Intent, um die
Dienst, ein ServiceConnection
-Implementierung zum Warten auf Verbindungs- und Trennungsereignisse sowie ein Flag
um zusätzliche Verbindungsoptionen anzugeben.
Kotlin
class DeviceControlActivity : AppCompatActivity() {
private var bluetoothService : BluetoothLeService? = null
// Code to manage Service lifecycle.
private val serviceConnection: ServiceConnection = object : ServiceConnection {
override fun onServiceConnected(
componentName: ComponentName,
service: IBinder
) {
bluetoothService = (service as LocalBinder).getService()
bluetoothService?.let { bluetooth ->
// call functions on service to check connection and connect to devices
}
}
override fun onServiceDisconnected(componentName: ComponentName) {
bluetoothService = null
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.gatt_services_characteristics)
val gattServiceIntent = Intent(this, BluetoothLeService::class.java)
bindService(gattServiceIntent, serviceConnection, Context.BIND_AUTO_CREATE)
}
}
Java
class DeviceControlActivity extends AppCompatActivity {
private BluetoothLeService bluetoothService;
private ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
bluetoothService = ((LocalBinder) service).getService();
if (bluetoothService != null) {
// call functions on service to check connection and connect to devices
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
bluetoothService = null;
}
};
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.gatt_services_characteristics);
Intent gattServiceIntent = new Intent(this, BluetoothLeService.class);
bindService(gattServiceIntent, serviceConnection, Context.BIND_AUTO_CREATE);
}
}
Bluetooth-Adapter einrichten
Sobald der Dienst an ihn gebunden ist, muss er auf den
BluetoothAdapter Er sollte
Prüfen Sie, ob der Adapter auf dem Gerät verfügbar ist. Weitere Informationen finden Sie unter Einrichtung
Bluetooth
BluetoothAdapter. Im folgenden Beispiel ist dieser Einrichtungscode
initialize()-Funktion, die einen Boolean-Wert zurückgibt, der einen Erfolg anzeigt.
Kotlin
private const val TAG = "BluetoothLeService"
class BluetoothLeService : Service() {
private var bluetoothAdapter: BluetoothAdapter? = null
fun initialize(): Boolean {
bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
if (bluetoothAdapter == null) {
Log.e(TAG, "Unable to obtain a BluetoothAdapter.")
return false
}
return true
}
...
}
Java
class BluetoothLeService extends Service {
public static final String TAG = "BluetoothLeService";
private BluetoothAdapter bluetoothAdapter;
public boolean initialize() {
bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (bluetoothAdapter == null) {
Log.e(TAG, "Unable to obtain a BluetoothAdapter.");
return false;
}
return true;
}
...
}
Die Aktivität ruft diese Funktion innerhalb ihrer ServiceConnection-Implementierung auf.
Ob der Rückgabewert der Funktion initialize() falsch ist, hängt davon ab,
. Sie könnten dem Nutzer eine Fehlermeldung anzeigen, die besagt, dass die
Das aktuelle Gerät unterstützt den Bluetooth-Betrieb nicht oder deaktiviert irgendwelche Funktionen
die Bluetooth erfordern. Im folgenden Beispiel
finish() wird bei der Aktivität aufgerufen
um den Nutzer
zum vorherigen Bildschirm zu wechseln.
Kotlin
class DeviceControlActivity : AppCompatActivity() {
// Code to manage Service lifecycle.
private val serviceConnection: ServiceConnection = object : ServiceConnection {
override fun onServiceConnected(
componentName: ComponentName,
service: IBinder
) {
bluetoothService = (service as LocalBinder).getService()
bluetoothService?.let { bluetooth ->
if (!bluetooth.initialize()) {
Log.e(TAG, "Unable to initialize Bluetooth")
finish()
}
// perform device connection
}
}
override fun onServiceDisconnected(componentName: ComponentName) {
bluetoothService = null
}
}
...
}
Java
class DeviceControlsActivity extends AppCompatActivity {
private ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
bluetoothService = ((LocalBinder) service).getService();
if (bluetoothService != null) {
if (!bluetoothService.initialize()) {
Log.e(TAG, "Unable to initialize Bluetooth");
finish();
}
// perform device connection
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
bluetoothService = null;
}
};
...
}
Mit einem Gerät verbinden
Sobald die BluetoothLeService-Instanz initialisiert ist, kann sie eine Verbindung zu BLE herstellen
. Die Aktivität muss die Geräteadresse an den Dienst senden, damit er
Initiieren Sie die Verbindung. Der Dienst ruft zuerst auf
getRemoteDevice()
auf dem BluetoothAdapter, um auf das Gerät zuzugreifen. Wenn der Adapter den
Gerät mit dieser Adresse wird, gibt getRemoteDevice() den Fehler
IllegalArgumentException
Kotlin
fun connect(address: String): Boolean {
bluetoothAdapter?.let { adapter ->
try {
val device = adapter.getRemoteDevice(address)
} catch (exception: IllegalArgumentException) {
Log.w(TAG, "Device not found with provided address.")
return false
}
// connect to the GATT server on the device
} ?: run {
Log.w(TAG, "BluetoothAdapter not initialized")
return false
}
}
Java
public boolean connect(final String address) {
if (bluetoothAdapter == null || address == null) {
Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
return false;
}
try {
final BluetoothDevice device = bluetoothAdapter.getRemoteDevice(address);
} catch (IllegalArgumentException exception) {
Log.w(TAG, "Device not found with provided address.");
return false;
}
// connect to the GATT server on the device
}
DeviceControlActivity ruft diese connect()-Funktion auf, sobald der Dienst
initialisiert. Die Aktivität muss die Adresse des BLE-Geräts übergeben. In
Im folgenden Beispiel wird die Geräteadresse als Intent
extra.
Kotlin
// Code to manage Service lifecycle.
private val serviceConnection: ServiceConnection = object : ServiceConnection {
override fun onServiceConnected(
componentName: ComponentName,
service: IBinder
) {
bluetoothService = (service as LocalBinder).getService()
bluetoothService?.let { bluetooth ->
if (!bluetooth.initialize()) {
Log.e(TAG, "Unable to initialize Bluetooth")
finish()
}
// perform device connection
bluetooth.connect(deviceAddress)
}
}
override fun onServiceDisconnected(componentName: ComponentName) {
bluetoothService = null
}
}
Java
private ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
bluetoothService = ((LocalBinder) service).getService();
if (bluetoothService != null) {
if (!bluetoothService.initialize()) {
Log.e(TAG, "Unable to initialize Bluetooth");
finish();
}
// perform device connection
bluetoothService.connect(deviceAddress);
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
bluetoothService = null;
}
};
GATT-Callback deklarieren
Sobald dem Dienst mitgeteilt wurde, mit welchem Gerät und zu welchem Dienst
eine Verbindung zum Gerät herstellt, muss der Dienst eine Verbindung zum GATT-Server
BLE-Gerät. Für diese Verbindung ist ein BluetoothGattCallback erforderlich
Benachrichtigungen über Verbindungsstatus, Diensterkennung, Merkmal
gelesenen und charakteristischen Benachrichtigungen.
In diesem Thema geht es um Benachrichtigungen zum Verbindungsstatus. Siehe Übertragung von BLE Daten für die Leistung Diensterkennung, charakteristische Lesevorgänge und Anfragemerkmal Benachrichtigungen.
Die
onConnectionStateChange()
wird ausgelöst, wenn sich die Verbindung zum GATT-Server des Geräts ändert.
Im folgenden Beispiel ist der Callback in der Klasse Service definiert, sodass er
kann mit der
BluetoothDevice, sobald das
eine Verbindung zu ihr herstellt.
Kotlin
private val bluetoothGattCallback = object : BluetoothGattCallback() {
override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
// successfully connected to the GATT Server
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
// disconnected from the GATT Server
}
}
}
Java
private final BluetoothGattCallback bluetoothGattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
// successfully connected to the GATT Server
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
// disconnected from the GATT Server
}
}
};
Mit GATT-Dienst verbinden
Sobald BluetoothGattCallback deklariert ist, kann der Dienst die Methode
BluetoothDevice-Objekt aus der Funktion connect(), um eine Verbindung zum GATT herzustellen
auf dem Gerät.
Die
connectGatt()
-Funktion verwendet wird. Hierfür ist ein Context-Objekt und ein boolescher Wert (autoConnect) erforderlich
und dem BluetoothGattCallback. In diesem Beispiel ist die App direkt
Die Verbindung zum BLE-Gerät wird hergestellt. Daher wird false für autoConnect übergeben.
Außerdem wird die Property BluetoothGatt hinzugefügt. Dadurch kann der Dienst die
Verbindung, wenn keine Verbindung besteht
nicht mehr benötigt wird.
Kotlin
class BluetoothLeService : Service() {
...
private var bluetoothGatt: BluetoothGatt? = null
...
fun connect(address: String): Boolean {
bluetoothAdapter?.let { adapter ->
try {
val device = adapter.getRemoteDevice(address)
// connect to the GATT server on the device
bluetoothGatt = device.connectGatt(this, false, bluetoothGattCallback)
return true
} catch (exception: IllegalArgumentException) {
Log.w(TAG, "Device not found with provided address. Unable to connect.")
return false
}
} ?: run {
Log.w(TAG, "BluetoothAdapter not initialized")
return false
}
}
}
Java
class BluetoothLeService extends Service {
...
private BluetoothGatt bluetoothGatt;
...
public boolean connect(final String address) {
if (bluetoothAdapter == null || address == null) {
Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
return false;
}
try {
final BluetoothDevice device = bluetoothAdapter.getRemoteDevice(address);
// connect to the GATT server on the device
bluetoothGatt = device.connectGatt(this, false, bluetoothGattCallback);
return true;
} catch (IllegalArgumentException exception) {
Log.w(TAG, "Device not found with provided address. Unable to connect.");
return false;
}
}
}
Broadcast-Updates
Wenn der Server eine Verbindung zum GATT-Server herstellt oder trennt, muss er benachrichtigt werden, die Aktivität des neuen Status. Dafür gibt es mehrere Möglichkeiten. Die Im folgenden Beispiel werden broadcasts zum Senden der vom Dienst bis zur Aktivität.
Der Dienst deklariert eine Funktion zur Übertragung des neuen Status. Diese Funktion nimmt
in einem Aktionsstring, der vor der Übertragung an ein Intent-Objekt übergeben wird
an das System gesendet werden.
Kotlin
private fun broadcastUpdate(action: String) {
val intent = Intent(action)
sendBroadcast(intent)
}
Java
private void broadcastUpdate(final String action) {
final Intent intent = new Intent(action);
sendBroadcast(intent);
}
Sobald die Broadcast-Funktion eingerichtet ist, wird sie im
BluetoothGattCallback, um Informationen zum Verbindungsstatus mit dem
GATT-Server. Konstanten und der aktuelle Verbindungsstatus des Dienstes werden deklariert
in dem Dienst, der die Intent-Aktionen darstellt.
Kotlin
class BluetoothLeService : Service() {
private var connectionState = STATE_DISCONNECTED
private val bluetoothGattCallback: BluetoothGattCallback = object : BluetoothGattCallback() {
override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
// successfully connected to the GATT Server
connectionState = STATE_CONNECTED
broadcastUpdate(ACTION_GATT_CONNECTED)
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
// disconnected from the GATT Server
connectionState = STATE_DISCONNECTED
broadcastUpdate(ACTION_GATT_DISCONNECTED)
}
}
}
...
companion object {
const val ACTION_GATT_CONNECTED =
"com.example.bluetooth.le.ACTION_GATT_CONNECTED"
const val ACTION_GATT_DISCONNECTED =
"com.example.bluetooth.le.ACTION_GATT_DISCONNECTED"
private const val STATE_DISCONNECTED = 0
private const val STATE_CONNECTED = 2
}
}
Java
class BluetoothLeService extends Service {
public final static String ACTION_GATT_CONNECTED =
"com.example.bluetooth.le.ACTION_GATT_CONNECTED";
public final static String ACTION_GATT_DISCONNECTED =
"com.example.bluetooth.le.ACTION_GATT_DISCONNECTED";
private static final int STATE_DISCONNECTED = 0;
private static final int STATE_CONNECTED = 2;
private int connectionState;
...
private final BluetoothGattCallback bluetoothGattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
// successfully connected to the GATT Server
connectionState = STATE_CONNECTED;
broadcastUpdate(ACTION_GATT_CONNECTED);
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
// disconnected from the GATT Server
connectionState = STATE_DISCONNECTED;
broadcastUpdate(ACTION_GATT_DISCONNECTED);
}
}
};
…
}
In Aktivitäten auf Updates warten
Sobald der Dienst die Verbindungsaktualisierungen sendet, muss die Aktivität
Implementiere eine BroadcastReceiver.
Registrieren Sie diesen Empfänger beim Einrichten der Aktivität und heben Sie die Registrierung auf, wenn das
wenn eine Aktivität den Bildschirm verlässt. Durch das Warten auf Ereignisse vom Dienst
Die Aktivität kann die Benutzeroberfläche auf Grundlage der aktuellen
Verbindungsstatus mit dem BLE-Gerät.
Kotlin
class DeviceControlActivity : AppCompatActivity() {
...
private val gattUpdateReceiver: BroadcastReceiver = object : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
when (intent.action) {
BluetoothLeService.ACTION_GATT_CONNECTED -> {
connected = true
updateConnectionState(R.string.connected)
}
BluetoothLeService.ACTION_GATT_DISCONNECTED -> {
connected = false
updateConnectionState(R.string.disconnected)
}
}
}
}
override fun onResume() {
super.onResume()
registerReceiver(gattUpdateReceiver, makeGattUpdateIntentFilter())
if (bluetoothService != null) {
val result = bluetoothService!!.connect(deviceAddress)
Log.d(DeviceControlsActivity.TAG, "Connect request result=$result")
}
}
override fun onPause() {
super.onPause()
unregisterReceiver(gattUpdateReceiver)
}
private fun makeGattUpdateIntentFilter(): IntentFilter? {
return IntentFilter().apply {
addAction(BluetoothLeService.ACTION_GATT_CONNECTED)
addAction(BluetoothLeService.ACTION_GATT_DISCONNECTED)
}
}
}
Java
class DeviceControlsActivity extends AppCompatActivity {
...
private final BroadcastReceiver gattUpdateReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
if (BluetoothLeService.ACTION_GATT_CONNECTED.equals(action)) {
connected = true;
updateConnectionState(R.string.connected);
} else if (BluetoothLeService.ACTION_GATT_DISCONNECTED.equals(action)) {
connected = false;
updateConnectionState(R.string.disconnected);
}
}
};
@Override
protected void onResume() {
super.onResume();
registerReceiver(gattUpdateReceiver, makeGattUpdateIntentFilter());
if (bluetoothService != null) {
final boolean result = bluetoothService.connect(deviceAddress);
Log.d(TAG, "Connect request result=" + result);
}
}
@Override
protected void onPause() {
super.onPause();
unregisterReceiver(gattUpdateReceiver);
}
private static IntentFilter makeGattUpdateIntentFilter() {
final IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(BluetoothLeService.ACTION_GATT_CONNECTED);
intentFilter.addAction(BluetoothLeService.ACTION_GATT_DISCONNECTED);
return intentFilter;
}
}
Gehen Sie unter BLE-Daten übertragen so vor:
Das BroadcastReceiver wird auch verwendet, um die Diensterkennung als
sowie die charakteristischen Daten des Geräts.
GATT-Verbindung trennen
Ein wichtiger Schritt bei Bluetooth-Verbindungen ist das Schließen der
wenn Sie fertig sind. Rufen Sie dazu close() auf.
für das BluetoothGatt-Objekt. Im folgenden Beispiel hat der Dienst
enthält den Verweis auf das BluetoothGatt. Wenn die Aktivität von der
wird die Verbindung getrennt, damit der Geräteakku nicht belastet wird.
Kotlin
class BluetoothLeService : Service() {
...
override fun onUnbind(intent: Intent?): Boolean {
close()
return super.onUnbind(intent)
}
private fun close() {
bluetoothGatt?.let { gatt ->
gatt.close()
bluetoothGatt = null
}
}
}
Java
class BluetoothLeService extends Service {
...
@Override
public boolean onUnbind(Intent intent) {
close();
return super.onUnbind(intent);
}
private void close() {
if (bluetoothGatt == null) {
Return;
}
bluetoothGatt.close();
bluetoothGatt = null;
}
}