Outre ceux qui développent généralement des applications, Bluetooth Low Energy est utilisé pour le travail électronique, etc. Pour ceux qui disent "je veux mordre un peu" (principalement moi), l'API BLE d'Android semble un peu difficile à utiliser.
Je pensais que c'était une raison difficile de faire diverses choses, alors je l'ai développée dans le but de créer une bibliothèque aussi simple et facile à utiliser que possible.
Il s'agit d'une bibliothèque qui simplifie le fonctionnement et nécessite des connaissances de base sur BLE. Nous vous recommandons de lire Getting Started with Bluetooth Low Energy (Make: PROJECTS) Kevin Townsend.
Pour ceux qui y sont habitués, RxAndroidBLE et [Bletia: Gérez Android BLE avec une API moderne](https://qiita.com/izumin5210/ items / 374d532a252c15aeb484) est recommandé. C'est probablement beaucoup plus propre et sans bugs.
... Pourquoi avez-vous créé une telle bibliothèque?
Tous les traitements asynchrones liés à BLE de l'API Android ont été modifiés en ** traitement synchrone. ** ** À l'origine, j'aurais dû utiliser des promesses, mais j'ai donné la priorité à la simplicité.
Ainsi, par exemple, si vous souhaitez communiquer avec BBC micro: bit, vous pouvez le faire avec le code suivant. (En fait, vous devez l'exécuter dans un thread distinct de l'interface utilisateur.)
private LazyBLEWrapper ble = new LazyBLEWrapper();
private final String LEDServiceUUID = "E95DD91D-251D-470A-A062-FA1922DFA9A8";
private final String LEDTextCharacteristicUUID = "E95D93EE-251D-470A-A062-FA1922DFA9A8";
private final String ButtonServiceUUID = "E95D9882-251D-470A-A062-FA1922DFA9A8";
private final String ButtonACharacteristicUUID = "E95DDA90-251D-470A-A062-FA1922DFA9A8";
private final String UARTServiceUUID = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E";
private final String UARTTxCharacteristicUUID = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E";
private final String UARTRxCharacteristicUUID = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E";
private final int timeout = 30*1000;
//analyse. C'est une correspondance de préfixe
BluetoothDevice device = ble.scanDevice(this,"BBC micro:bit", timeout);
//Lien
ble.connect(this,device, timeout);
//Rappeler une fois déconnecté(Tout)
ble.setDisconnectCallback(new LazyBLEWrapper.DisconnectCallback() {
@Override
public void onDisconnect() {
Log.e(TAG,"Disconnected!");
}
});
//À LED"Hello World"Et écris
ble.writeData("Hello World",LEDServiceUUID,LEDTextCharacteristicUUID, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT,timeout);
//Acquiert et affiche l'état de la pression du bouton
Integer dat = ble.readDataInt(ButtonServiceUUID,ButtonACharacteristicUUID,BluetoothGattCharacteristic.FORMAT_UINT8,0,timeout);
Log.d(TAG, dat.toString());
//Définir la notification
ble.setNotify(ButtonServiceUUID,ButtonACharacteristicUUID,true,timeout);
//Définir l'indication
ble.setIndicate(UARTServiceUUID,UARTTxCharacteristicUUID,true,timeout);
//Définissez le rappel. Ceci est exécuté par UIThread.
ble.setNotificationCallback(new LazyBLEWrapper.NotificationCallback() {
@Override
public void onNotification(BluetoothGattCharacteristic characteristic) {
if(ble.isMatchCharacteristicUUID(characteristic,ButtonACharacteristicUUID)) {
Integer ButtonA = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 0);
Log.d(TAG, ButtonA.toString());
}
if(ble.isMatchCharacteristicUUID(characteristic,UARTTxCharacteristicUUID)) {
Log.d(TAG, characteristic.getStringValue(0));
}
}
});
//Transmission UART
ble.writeData("Hello UART\n",UARTServiceUUID,UARTRxCharacteristicUUID,BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT,timeout);
//Déconnecter
ble.disconnect(timeout);
//ble.forceDisconnect();
Si vous souhaitez utiliser des fonctions approfondies, vous pouvez utiliser l'API standard en premier lieu, alors affinez les fonctions Nous l'avons implémenté simplement en nous concentrant sur les ** fonctions fréquemment utilisées **.
Le cas d'utilisation est donc
Seulement.
Puisqu'il s'agit d'une méthode synchrone, vous pouvez l'écrire dans un flux simple. (Bien que les threads soient requis) Puisqu'il n'est pas asynchrone, toutes les méthodes avec latence ont une spécification de délai.
Il comprend également le processus d'acquisition de l'autorité d'informations de localisation détaillées, qui est requise lors de l'utilisation de BLE sur Android 6.0 ou version ultérieure.
Les opérations caractéristiques (setValue, getValue, etc.) au moment de la notification ne sont pas incluses, donc Il utilise les méthodes API Android standard.
Fondamentalement, car il est conçu pour renvoyer l'objet API Android BLE tel quel Si vous voulez faire de petites choses, vous pouvez utiliser l'API autour de cela.
Télécharger ici Pour plus de simplicité, Android 5.0 ou version ultérieure n'est pas pris en charge. La licence est une licence zlib.
Nous avons confirmé l'opération uniquement sur Nexus 5X (Android 8.0).
Afin de simplifier la mise en œuvre, les paramètres du terminal et les relations d'autorisation d'exécution sont également fournis. Il est normal d'exécuter ces méthodes dans un thread d'interface utilisateur. (Il sera terminé sans temps d'attente.)
v0.13: Vous ne conservez plus le contexte en interne, vous devez donc transmettre le contexte ou l'activité.
//Vérifiez si la fonction BLE du terminal est activée. Avant la communication, etc.
boolean isBluetoothFeatureEnabled()
//Faites une demande pour activer la fonction Bluetooth du terminal.
void requestTurnOnBlueTooth(AppCompatActivity activity)
//Vérifiez si le terminal prend en charge la fonction BLE.
boolean isBluetoothFeatureSupported(Context context)
//Vérifiez si vous disposez des autorisations de localisation détaillées.
//Requis pour l'analyse BLE.
boolean isPermitted(Context context)
//Demandez des autorisations de localisation détaillées.
//À l'origine, il est fait par Activity et ce n'est pas recommandé, mais pour le moment, il peut être utilisé lorsque cela est gênant comme lors de la réalisation d'un prototype.
//À l'origine, il est nécessaire de recevoir l'intention et de la traiter, mais cela fonctionne sans elle, donc elle n'est pas mise en œuvre. Veuillez mettre en œuvre du côté activité.
void permissionRequest(AppCompatActivity activity)
Pour le moment, je l'ai réduit aux trois types suivants, dont je me demande si c'est tout ce dont j'ai besoin.
v0.13: Vous ne conservez plus le contexte en interne, vous devez donc transmettre le contexte ou l'activité. En outre, il a été modifié pour que le thread d'interface utilisateur appelle en interne le traitement lié à BLE.
//Scannez les périphériques environnants.
//Continuer l'analyse jusqu'à expiration du délai, ArrayList par ordre de découverte<BluetoothDevice>Stocker et retourner.
//S'il n'est pas trouvé, renvoie 0 listes.
ArrayList<BluetoothDevice> scanDevice(Context context, int timeOut) throws IOException
//Scannez les périphériques environnants.
//Vérifie le nom de l'appareil avec une correspondance de préfixe et renvoie immédiatement le premier appareil correspondant.
//S'il n'est pas trouvé, déclenchez une exception.
BluetoothDevice scanDevice(Context context, String deviceName, int timeOut) throws IOException
//Liaison des bornes(Appairage)Recherchez dans la liste des périphériques terminés.
//Vérifie le nom de l'appareil avec une correspondance de préfixe et renvoie immédiatement le premier appareil correspondant.
//S'il n'est pas trouvé, renvoie null.
BluetoothDevice scanBondedDevice(String deviceName)
Il semble difficile de gérer les objets GATT (nombreux rappels), alors je l'ai tenu. Par conséquent, il est simple et n'a pas de valeur de retour.
v0.13: Vous ne conservez plus le contexte en interne, vous devez donc transmettre le contexte ou l'activité. En outre, il a été modifié pour que le thread d'interface utilisateur appelle en interne le traitement lié à BLE. Le processus de déconnexion est devenu plus poli et il y a un temps d'attente. Pour la déconnexion à la fin de l'application, nous recommandons de forcer la déconnexion sans temps d'attente. Une seule connexion GATT peut être maintenue en interne par instance. v0.14: lance désormais une exception lors de la tentative de connexion lors de la connexion.
//Connectez-vous à l'appareil et effectuez une analyse de service. Les objets du GATT sont conservés en interne.
//(Pour effectuer automatiquement le traitement de découpe, etc.)
//Déclenche une exception si la connexion échoue.
void connect(Context context, BluetoothDevice device, int timeOut) throws IOException
//Déconnectez-vous de l'appareil.
void disconnect(int timeOut)
//Déconnexion forcée de l'appareil(Processus de déconnexion dans l'ancienne version)
//Cela peut être fait dans un thread d'interface utilisateur
void forceDisconnect()
Pour la lecture et l'écriture de caractéristiques simples, nous l'avons amélioré dans la v0.11 pour le rendre plus simple. Rechercher des services, rechercher des caractéristiques, attribuer des valeurs, etc. sur une seule ligne.
C'est beaucoup de lecture, mais je l'ai mis en correspondance avec l'API Android. Tous les formats disponibles sont pris en charge. Par contre, pour l'écriture, float a été omis. Parce que c'était un style qui semblait un peu difficile à utiliser La décision est qu'il n'y a pas beaucoup d'occasions d'écrire des points flottants.
//**********en train de lire***********
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Les dernières données sont obtenues à partir du périphérique, interprétées avec le format et le décalage spécifiés, et renvoyées sous forme de type entier.
//Déclenche une exception lorsque la communication échoue.
int readDataInt(String ServiceUUID,String CharacteristicUUID,int formatType,int offset,int timeOut) throws IOException
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Les dernières données sont obtenues à partir du périphérique, interprétées avec le format et le décalage spécifiés, et renvoyées sous forme de type à virgule flottante.
//Déclenche une exception lorsque la communication échoue.
float readDataFloat(String ServiceUUID,String CharacteristicUUID,int formatType,int offset,int timeOut) throws IOException
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Obtenez les dernières données du périphérique et renvoyez-les sous forme de chaîne d'octets.
//Déclenche une exception lorsque la communication échoue.
byte[] readDataValue(String ServiceUUID,String CharacteristicUUID,int timeOut) throws IOException
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Les dernières données sont obtenues à partir du périphérique, interprétées au décalage spécifié et renvoyées sous forme de chaîne de caractères.
//Déclenche une exception lorsque la communication échoue.
String readDataString(String ServiceUUID,String CharacteristicUUID,int offset,int timeOut) throws IOException
//**********l'écriture***********
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Définissez la chaîne de caractères spécifiée comme contenu du périphérique avec la méthode d'écriture spécifiée.
//Déclenche une exception lorsque la communication échoue.
void writeData(String string,String ServiceUUID,String CharacteristicUUID,int writeType,int timeOut) throws IOException
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Définissez la chaîne d'octets spécifiée comme contenu du périphérique avec la méthode d'écriture spécifiée.
//Déclenche une exception lorsque la communication échoue.
void writeData(byte[] value,String ServiceUUID,String CharacteristicUUID,int writeType,int timeOut) throws IOException
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Avec la méthode d'écriture spécifiée, définissez l'entier spécifié comme contenu du périphérique.
//Déclenche une exception lorsque la communication échoue.
void writeData(int num,int formatType,int offset,String ServiceUUID,String CharacteristicUUID,int writeType,int timeOut) throws IOException
Le formatType est le suivant.
BluetoothGattCharacteristic.FORMAT_FLOAT //(32-bit float)
BluetoothGattCharacteristic.FORMAT_SFLOAT //(16-bit float)
BluetoothGattCharacteristic.FORMAT_SINT16
BluetoothGattCharacteristic.FORMAT_SINT32
BluetoothGattCharacteristic.FORMAT_SINT8
BluetoothGattCharacteristic.FORMAT_UINT16
BluetoothGattCharacteristic.FORMAT_UINT32
BluetoothGattCharacteristic.FORMAT_UINT8
Le writeType est le suivant.
BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT
BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
BluetoothGattCharacteristic.WRITE_TYPE_SIGNED
Comme les paramètres de notification sont également standard, nous avons rendu possible leur écriture sous forme abrégée. Puisque setNotify est le paramètre du côté périphérique et setCallback est le paramètre du côté Android, les deux sont requis.
Cependant, un seul callback peut être enregistré avec setCallback, et la caractéristique est en interne Puisqu'il s'agit d'une forme de vérification et de branchement, setCallback ne doit être effectué qu'une seule fois au début de l'application.
L'indication est prise en charge à partir de la v0.12.
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Active / désactive le paramètre de notification du côté périphérique pour cette caractéristique.
//Déclenche une exception lorsque la communication échoue.
void setNotify(String ServiceUUID,String CharacteristicUUID,boolean enable,int timeOut) throws IOException
//Obtenez la caractéristique de service à partir de la chaîne UUID de service spécifiée, chaîne UUID caractéristique,
//Active / désactive le paramètre Indication sur le côté périphérique pour cette caractéristique.
//Déclenche une exception lorsque la communication échoue.
void setIndicate(String ServiceUUID,String CharacteristicUUID,boolean enable,int timeOut) throws IOException
v0.14: veuillez définir null pour annuler le rappel.
//Définissez le rappel lorsqu'une notification est reçue du périphérique.
void setNotificationCallback(final NotificationCallback callback)
//Rappel une fois déconnecté
void setDisconnectCallback(final DisconnectCallback callback){
//Vérifiez si l'UUID caractéristique et la chaîne UUID sont localisés
//Ture s'ils correspondent, faux sinon
//Il peut être utilisé pour identifier la caractéristique envoyée par Notification ou Indication.
boolean isMatchCharacteristicUUID(BluetoothGattCharacteristic characteristic,String CharacteristicUUID)
//Interface de rappel pour les notifications
interface NotificationCallback {
void onNotification(BluetoothGattCharacteristic characteristic);
}
//Interface de rappel lors de la déconnexion
interface DisconnectCallback {
void onDisconnect();
}
C'est l'opération caractéristique fournie par la v0.10. Vous pouvez obtenir la caractéristique brute, veuillez donc l'utiliser si vous souhaitez effectuer des opérations détaillées.
Si vous venez de lire et d'écrire, prenez le service, puis la caractéristique, C'est un peu compliqué car vous avez besoin d'au moins 4 lignes dans l'ordre de fonctionnement et d'émission.
v0.13: s'exécute désormais en interne dans le thread d'interface utilisateur. Contrôle nul amélioré.
//Obtenez le service à partir de la chaîne UUID à l'aide des informations de service recherchées.
//S'il n'est pas trouvé, renvoie null.
BluetoothGattService getService(String serviceUUID)
//Utilisez les informations de service recherchées pour obtenir la caractéristique de la chaîne UUID.
//BluetoothGattService acquis par getService est nécessaire pour déterminer la caractéristique avec le même UUID.
//S'il n'est pas trouvé, renvoie null.
BluetoothGattCharacteristic getCharacteristicInService(BluetoothGattService service, String CharacteristicUUID)
//Refléter le contenu de la caractéristique actuelle dans le périphérique.
//Déclenche une exception lorsque la communication échoue.
void writeCharacteristic(BluetoothGattCharacteristic characteristic, int timeOut) throws IOException
//Obtient le dernier contenu caractéristique du périphérique et le renvoie.
//(À ce moment, la caractéristique originale est probablement inchangée.)
//Déclenche une exception lorsque la communication échoue.
BluetoothGattCharacteristic readCharacteristic(BluetoothGattCharacteristic characteristic, int timeOut) throws IOException
Opération de descripteur. Il est utilisé en interne pour les paramètres de notification. Notez que je n'ai pas beaucoup testé.
v0.13: s'exécute désormais en interne dans le thread d'interface utilisateur. Contrôle nul amélioré.
//Écrivez le descripteur sur le périphérique.
//Déclenche une exception lorsque la communication échoue.
void writeDescriptor(BluetoothGattDescriptor descriptor, int timeOut) throws IOException
//Lisez le descripteur sur le périphérique.
//Déclenche une exception lorsque la communication échoue.
BluetoothGattDescriptor readDescriptor(BluetoothGattDescriptor descriptor, int timeOut) throws IOException
//Active / désactive le paramètre de notification sur le côté périphérique d'une caractéristique spécifique.
//Déclenche une exception lorsque la communication échoue.
void setNotification(BluetoothGattCharacteristic characteristic,boolean enable,int timeOut) throws IOException
//Active / désactive le paramètre Indication sur le côté périphérique d'une caractéristique spécifique.
//Déclenche une exception lorsque la communication échoue.
void setIndication(BluetoothGattCharacteristic characteristic,boolean enable,int timeOut) throws IOException
//Passez le Bluetooth Gatt qui se trouve à l'intérieur. S'il est nul, il est déconnecté.
//Veuillez noter qu'il sera invalidé sans autorisation lorsque la communication sera déconnectée.
BluetoothGatt getGatt()
//Active ou désactive les journaux très redondants.
//Activé par défaut(Je pense que c'est souvent utilisé pour le prototypage)
//En passant false, seuls les journaux fatals seront générés.
void setDebug(boolean f)
//Vérifiez si une méthode est en cours d'exécution
//boolean getLockState()
//Ouverture forcée
//void forceUnlock()
Ce n'est pas une méthode de bibliothèque, mais c'est un gars que j'utilise beaucoup.
//Demandez au système d'exploitation de se lier au périphérique spécifié.
//Le type de liaison effectué dépend de la conception du périphérique.
device.createBond();
//Définissez la valeur de manière caractéristique.
//À utiliser avec writeCharacteristic.
characteristic.setValue("Hello World");
//Extrait la valeur de la caractéristique dans le format spécifié.
//À utiliser avec readCharacteristic.
characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, offset);
Il a été créé par des débutants Android et des débutants java pour plus de débutants, Je suis un débutant depuis quelques minutes, donc je pense qu'il y a diverses choses étranges.
Si vous trouvez une bibliothèque plus utile ou quelque chose d'étrange ici, veuillez nous le faire savoir dans les commentaires.
J'ai beaucoup parlé des sites suivants.
Les différentes douleurs que j'ai éprouvées au cours du développement ont déjà été écrites il y a deux ans. #kyobashidex qu'Android BLE a beaucoup parlé sur kyobashi.dex
Et ici. 5 TIPS FOR BLUETOOTH LOW ENERGY (BLE) ON ANDROID
Nous avons confirmé l'opération avec Nexus 5X (Android 8.0) et BBC micro: bit. Veuillez vous référer à ce site pour la préparation côté micro: bit. Essayez la communication BLE avec Micro: bit en utilisant uniquement le navigateur utilisant l'API Web Bluetooth.
AndroidManifest.xml
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-feature android:name="android.hardware.bluetooth_le" android:required="true"/>
<uses-feature android:name="android.hardware.location.gps" />
MainActivity.java
package jp.ne.sakura.sabowl.gpsnmeajp.bletest;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGattCharacteristic;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.UUID;
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
...
final String LEDServiceUUID = "E95DD91D-251D-470A-A062-FA1922DFA9A8";
final String LEDTextCharacteristicUUID = "E95D93EE-251D-470A-A062-FA1922DFA9A8";
final String ButtonServiceUUID = "E95D9882-251D-470A-A062-FA1922DFA9A8";
final String ButtonACharacteristicUUID = "E95DDA90-251D-470A-A062-FA1922DFA9A8";
private LazyBLEWrapper ble = new LazyBLEWrapper(this);
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
...
ble.setDebug(true);
if(!ble.isBluetoothFeatureSupported(this))
{
Toast.makeText(this, "C'est un terminal qui ne peut pas utiliser Bluetooth", Toast.LENGTH_LONG).show();
finish();
}
if(!ble.isPermitted(this)){
ble.permissionRequest(this);
}
}
void connect()
{
try {
//Détection de périphérique.
//ArrayList<BluetoothDevice> result = ble.scanDevice(this,5000); //Analyser tous les appareils
//BluetoothDevice device = ble.scanDevice(this,"BBC micro:bit", 5000); //Analyse de nom avec correspondance de préfixe
BluetoothDevice device = ble.scanBondedDevice("BBC micro:bit"); //Recherchez dans la liste liée.(Aucune autorisation de poste détaillée requise)
//device.createBond();//liaison
//Lien
ble.connect(this,device, 30000);
ble.setDisconnectCallback(new LazyBLEWrapper.DisconnectCallback() {
@Override
public void onDisconnect() {
Log.e(TAG,"Disconnected!");
}
});
//Écriture LED
ble.writeData("Hello",LEDServiceUUID,LEDTextCharacteristicUUID, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT,30000);
//Obtenir le bouton
Integer dat = ble.readDataInt(ButtonServiceUUID,ButtonACharacteristicUUID,BluetoothGattCharacteristic.FORMAT_UINT8,0,30000);
Log.d(TAG, dat.toString());
//Paramètres de notification des boutons
ble.setNotify(ButtonServiceUUID,ButtonACharacteristicUUID,true,30000);
//Paramètre de réception UART
ble.setIndicate(UARTServiceUUID,UARTTxCharacteristicUUID,true,30000);
ble.setNotificationCallback(new LazyBLEWrapper.NotificationCallback() {
@Override
public void onNotification(BluetoothGattCharacteristic characteristic) {
if(ble.isMatchCharacteristicUUID(characteristic,ButtonACharacteristicUUID)) {
Integer ButtonA = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 0);
Log.d(TAG, ButtonA.toString());
mText.setText(ButtonA.toString());
}
if(ble.isMatchCharacteristicUUID(characteristic,UARTTxCharacteristicUUID)) {
Log.d(TAG, characteristic.getStringValue(0));
}
}
});
//Transmission UART
ble.writeData("Hello UART\n",UARTServiceUUID,UARTRxCharacteristicUUID,BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT,30000);
}catch (Exception e){
Log.e(TAG,"connect",e);
ble.forceDisconnect();
}
}
void disconnect(){
try {
// ble.setNotify(ButtonServiceUUID,ButtonACharacteristicUUID,false,30000);
// ble.setDisconnectCallback(null);
// ble.setNotificationCallback(null);
ble.disconnect(30*1000);
// finish();
}catch (Exception e){
Log.e(TAG,"disconnect",e);
ble.forceDisconnect();
}
}
public void onClick(View v) {
Button btn = (Button)v;
Log.i(TAG,"onClick");
switch( btn.getId() ){
//Lorsque le bouton est enfoncé
case R.id.buttonConnect:
//Traitement BLE
if(ble.isBluetoothFeatureEnabled())
{
//Ne pas courir sur le thread principal car il se verrouille(Je ne reviendrai pas pour le reste de ma vie))
new Thread(new Runnable() {
@Override
public void run() {
connect();
}
}).start();
}else{
ble.requestTurnOnBlueTooth(this);
}
mText.setText("Wow!");
break;
case R.id.buttonDisconnect:
//Ne pas courir sur le thread principal car il se verrouille(Je ne reviendrai pas pour le reste de ma vie))
new Thread(new Runnable() {
@Override
public void run() {
disconnect();
}
}).start();
break;
default:
break;
}
}
Recommended Posts