Sujet Précédent Sujet Suivant

Bluetooth android envoyé un texte

adrian001 Messages postés 2 Date d'inscription mardi 8 septembre 2015 Statut Membre Dernière intervention 13 septembre 2015 - Modifié par adrian001 le 8/09/2015 à 21:34
Twinuts Messages postés 5375 Date d'inscription dimanche 4 mai 2003 Statut Modérateur Dernière intervention 14 juin 2023 - 12 oct. 2015 à 12:54
Bonjour,
apres des recherches et des recherches et je n'ai pas pu resoudre mon probleme donc je viens vers vous

bref j'ai trouvé ça dans ce site:
http://codes-sources.commentcamarche.net/forum/affich-1616468-les-classes

le tutorial est clair il n'y a pas de soucis mais quand je fais copier/coller de code pour le tester s'il marche ou pas l'application se plante.

apres une revision total de ce code java et le fichier xml, j'ai vu que le probleme se trouve dans la fonction socket.connect();

apres tracer le code j'ai vu que le probleme vient de device

- pour le bluetooth je paire le périphérique manuellement afin de facilité la lecture de code, donc il y'a un device déjà connecte avec mon téléphone.

j'ai donc modifier le code et voici ma modification: 


import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Set;
import java.util.UUID;

public class BtInterface {

    private BluetoothDevice device = null;
    private BluetoothSocket socket = null;
    private InputStream receiveStream = null;
    private OutputStream sendStream = null;
    BluetoothAdapter bluetoothAdapter;
    public UUID serverUuid = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb") ;

    private ReceiverThread receiverThread;

    Handler handler;

    public BtInterface(Handler hstatus, Handler h) {
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        Set<BluetoothDevice> setpairedDevices = bluetoothAdapter.getBondedDevices();
        if (setpairedDevices.size() > 0) {
            for (BluetoothDevice bluetoothDevice : setpairedDevices) {
                try {
                    socket = bluetoothDevice.createRfcommSocketToServiceRecord(serverUuid);
                    Log.e("",bluetoothDevice.getName());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        BluetoothDevice[] pairedDevices = (BluetoothDevice[]) setpairedDevices.toArray(new BluetoothDevice[setpairedDevices.size()]);

                try {

                    receiveStream = socket.getInputStream();
                    sendStream = socket.getOutputStream();
                } catch (IOException e) {
                    e.printStackTrace();
                }


        handler = hstatus;

        receiverThread = new ReceiverThread(h);
    }

    public void sendData(String data) {
        sendData(data, false);
    }

    public void sendData(String data, boolean deleteScheduledData) {
        try {
            sendStream.write(data.getBytes());
            sendStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void connect() {
        new Thread() {
            @Override public void run() {
                try {

                    socket.connect();

                    Message msg = handler.obtainMessage();
                    msg.arg1 = 1;
                    handler.sendMessage(msg);

                    receiverThread.start();

                } catch (IOException e) {
                    Log.v("N", "Connection Failed : "+e.getMessage());
                    e.printStackTrace();
                }
            }
        }.start();
    }

    public void close() {
        try {
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public BluetoothDevice getDevice() {
        return device;
    }

    private class ReceiverThread extends Thread {
        Handler handler;

        ReceiverThread(Handler h) {
            handler = h;
        }

        @Override public void run() {
            while(true) {
                try {
                    if(receiveStream.available() > 0) {

                        byte buffer[] = new byte[100];
                        int k = receiveStream.read(buffer, 0, 100);

                        if(k > 0) {
                            byte rawdata[] = new byte[k];
                            for(int i=0;i<k;i++)
                                rawdata[i] = buffer[i];

                            String data = new String(rawdata);

                            Message msg = handler.obtainMessage();
                            Bundle b = new Bundle();
                            b.putString("receivedData", data);
                            msg.setData(b);
                            handler.sendMessage(msg);
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}



là, l'application ne plante plus, mais elle fait rien non plus, j'ai passé par le debugeur j'ai trouvé ce probleme:

W/BluetoothAdapter? getBluetoothService() called with no BluetoothManagerCallback

vraiment j'ai besoin de vos aides. en fait.

Merci d'avance
A voir également:

3 réponses

Réponse 1 / 3
Twinuts Messages postés 5375 Date d'inscription dimanche 4 mai 2003 Statut Modérateur Dernière intervention 14 juin 2023 111
9 sept. 2015 à 09:57
Salut,

Dsl, j'ai méchamment la flemme de lire le code... du coup je vais te faire un ptit code d'exemple (client only en espérant que ton serveur supporte les échanges de String's) pour échanger des String ; Ici comme toi je considère que le pairing est fait

Dans un premier temps assure toi d'avoir les bonnes permissions: 
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />


interface BluetoothListener.java 
public interface BluetoothListener {
  
  void bluetoothMessage(final String message);
  
  void bluetoothError(final String error);
  
  void bluetoothConnectionSate(final boolean connected);
  
}


classe BluetoothClient.java 

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Set;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class BluetoothClient implements Runnable {
  private final static String         TAG           = BluetoothClient.class
      .getSimpleName();
  /* Messages echangés via le handler */
  private static final int            READY_TO_CONN = 0;
  private static final int            CANCEL_CONN   = 1;
  private static final int            MESSAGE_READ  = 2;

  private static final java.util.UUID UUID          = java.util.UUID
                                                        .fromString("05f2934c-1e81-4554-bb08-44aa761afbfb");

  /* Ici je ne gère qu'un device de connecté */
  private String                      deviceAddr    = null;

  private boolean                     mCancel       = false;
  private Handler                     mHandler      = null;
  private BluetoothAdapter            mAdapter      = null;
  private InputStream                 mInStream     = null;
  private OutputStream                mOutStream    = null;
  private BluetoothSocket             mSocket       = null;

  public BluetoothClient(final BluetoothListener listener) {
    mHandler = new Handler(Looper.getMainLooper()) {
      @Override
      public void handleMessage(final Message msg) {
        switch (msg.what) {
          case READY_TO_CONN: /* Etat de la connection */
            listener.bluetoothConnectionSate(true);
            break;
          case CANCEL_CONN: /* Etat de la connection */
            listener.bluetoothConnectionSate(false);
            break;
          case MESSAGE_READ: /* reception d'un message */
            final String readMessage = new String((byte[]) msg.obj, 0, msg.arg1);
            listener.bluetoothMessage(readMessage);
            break;
          default:
            break;
        }
      }
    };
    mAdapter = BluetoothAdapter.getDefaultAdapter();
    if (mAdapter == null)
      listener.bluetoothError("Bluetooth non supporté");
    else if (!mAdapter.isEnabled()) {
      listener.bluetoothError("Bluetooth non activé");
    } else {
      /* ok on commence */
      final Set<BluetoothDevice> pairedDevices = mAdapter.getBondedDevices();
      // If there are paired devices
      if (pairedDevices.size() > 0) {
        final BluetoothDevice device = pairedDevices.iterator().next();
        /* Stock l'adresse pour créer le device bluetooth */
        deviceAddr = device.getAddress();
        mCancel = false;
        /*
         * démarre le thread pour la connection et la lecture de nouveaux
         * messages
         */
        final Thread t = new Thread(this);
        t.start();
      } else {
        Log.i(TAG, "startDiscovery");
        mAdapter.startDiscovery(); // normalement il faut gérer plus à ce niveau
                                   // si tu veux supporter le process de
                                   // pairing.
      }
    }
  }

  private void sleep5s() {
    try {
      Thread.sleep(5000);
    } catch (final InterruptedException ex) {
    }
  }

  @Override
  public void run() {
    final BluetoothDevice dev = mAdapter.getRemoteDevice(deviceAddr);
    // Tentative de connexion.
    try {
      if (mSocket != null)
        mSocket.close();
      // J'ai moins de problèmes en insecure mais tu peux essayer sans.
      mSocket = dev.createInsecureRfcommSocketToServiceRecord(UUID);
    } catch (final Exception e) {
      Log.e(TAG, "createInsecureRfcommSocketToServiceRecord", e);
      e.printStackTrace();
      sleep5s(); // petite attente pour ne pas flooder avec des retry de
                 // connexions */
      /* evite la reentrance au moment du cancel */
      if (!mCancel)
        ioError();
      return;
    }
    // Stop de toutes discovery ; les inquiry en bluetooth satures les chip
    mAdapter.cancelDiscovery();
    Log.i(TAG, "Stopping discovery");

    try {
      // Connection avec le serveur.
      Log.i(TAG, "Connecting!");
      mSocket.connect();
    } catch (final IOException connectException) {
      Log.e(TAG, "failed to connect", connectException);
      sleep5s(); // petite attente pour ne pas flooder avec des retry de
                 // connexions */
      if (!mCancel)
        ioError();
      return;
    }
    Log.e(TAG, "Connected");
    // Récupération des flux IO pour dialoguer avec le serveur.
    try {
      mInStream = mSocket.getInputStream();
      mOutStream = mSocket.getOutputStream();
    } catch (final IOException e) {
      Log.e(TAG, "disconnected", e);
      ioError();
      return;
    }
    /* petite notification pur savoir que la connexion est faite */
    final Message msg = mHandler.obtainMessage(READY_TO_CONN);
    mHandler.sendMessage(msg);

    final byte[] buffer = new byte[1024];
    int bytes;
    // boucle de lecture des messages envoyés par le serveur.
    while (!mCancel) {
      try {
        // Lecture du message.
        bytes = mInStream.read(buffer);
        if (bytes == -1) {
          Log.e(TAG, "disconnected");
          ioError();
          break;
        }
        // Propagation du message recu.
        mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer).sendToTarget();
      } catch (final Exception e) {
        Log.e(TAG, "disconnected", e);
        ioError();
        break;
      }
    }
  }

  /** Permet l'ecriture d'un message sur le socket */
  public void write(final String buffer) {
    try {
      if (mOutStream != null)
        mOutStream.write(buffer.getBytes());
    } catch (final IOException e) {
      Log.e(TAG, "Exception during write", e);
      ioError();
    }
  }

  private void ioError() {
    Log.i(TAG, "connectionLost");
    cancel(); /* ferme le socket */
    /* notifie le handler pour l'activity */
    final Message msg = mHandler.obtainMessage(CANCEL_CONN);
    mHandler.sendMessage(msg);
  }

  /** Stop la connection et ferme le socket bluetooth */
  public void cancel() {
    mCancel = true;
    try {
      if (mSocket != null)
        mSocket.close();
    } catch (final IOException e) {
    }
    mSocket = null;
    mInStream = null;
    mOutStream = null;
  }
}


Exemple d'utilisation (je n'ai pas eclipse sous la main donc je n'ai pas testé cette activity)
Fichier main_activity.xml (dans res/layout) 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical"
    android:weightSum="5" >

    <TextView
        android:id="@+id/statusTV"
        android:layout_width="fill_parent"
        android:layout_height="0sp"
        android:layout_weight="1"
		android:text="statusTV"/>

    <TextView
        android:id="@+id/messageTV"
        android:layout_width="fill_parent"
        android:layout_height="0sp"
        android:layout_weight="3"
		android:text="messageTV" />

    <EditText
        android:id="@+id/messageET"
        android:layout_width="fill_parent"
        android:layout_height="0sp"
        android:layout_weight="1"
        android:inputType="text"/>

    <Button
        android:id="@+id/button"
        android:layout_gravity="end"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="sendBluetooth"
        android:text="Send" />

</LinearLayout>


Fichier MainActivity.java 

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity implements BluetoothListener {

  private TextView        statusTV  = null;
  private TextView        messageTV = null;
  private EditText        messageET = null;
  private Button          button    = null;
  private BluetoothClient btClient  = null;

  @Override
  protected void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    statusTV = (TextView) findViewById(R.id.statusTV);
    messageTV = (TextView) findViewById(R.id.messageTV);
    messageET = (EditText) findViewById(R.id.messageET);
    button = (Button) findViewById(R.id.button);
    buttonEnable(button, false);
    
    btClient = new BluetoothClient(this);
  }

  public void sendBluetooth(final View v) {
    btClient.write(messageET.getText().toString());
  }

  @Override
  public void bluetoothMessage(final String message) {
    messageTV.append(message);
    messageTV.append("\n");
  }

  @Override
  public void bluetoothError(final String error) {
    statusTV.setText("ERROR: " + error);
  }

  @Override
  public void bluetoothConnectionSate(final boolean connected) {
    statusTV.setText("Bluetooth connection " + (connected ? "DONE" : "LOST"));
    buttonEnable(button, connected);
    if (!connected)
      btClient.setUp();
  }

  @Override
  public void onBackPressed() {
    super.onBackPressed();
    btClient.cancel();
  }
  
  private void buttonEnable(Button bt, final boolean en) {
    bt.setEnabled(en);
    bt.setClickable(en);
  }

}



0
Réponse 2 / 3
adrian001 Messages postés 2 Date d'inscription mardi 8 septembre 2015 Statut Membre Dernière intervention 13 septembre 2015
13 sept. 2015 à 00:56
Re-salut;

je m'excuse pour ce retard dans ma reponse, bien j'ai testé votre code et il me donne des erreurs :/

vu qu'il ne marche pas donc je ne peux pas le prendre comme exemple que je peux l'étudier et le developper selon mes besoins.

bref;

pour que je pige le fonctionnement de code, veuillez SVP me repondre:

- si je me connecte les deux devices manuallement via bluetooth (paramettre puis appaire...), il me reste que créer une application pour envoyé le message et donc ce code suffit: 

    /** Permet l'ecriture d'un message sur le socket */
    public void write(final String buffer) {
        try {
            if (mOutStream != null)
                mOutStream.write(buffer.getBytes());
        } catch (final IOException e) {
            Log.e(TAG, "Exception during write", e);
            ioError();
        }
    }


vu qu'il y'a un commentaire dans votre code qui dit Permet l'écriture d'i, ùessage sur le socket cela dit qu'il me faut un socket donc je dois ajouter ça : 

BluetoothSocket socket = null;

                socketTmp = device.createRfcommSocketToServiceRecord(serverUuid);
                socket = socketTmp;
socket.connect();


je n'ai pas fait le try catch pour que tu lis facilement le code

s'il me manque un truc dis le moi SVP et merci
0
Réponse 3 / 3
Twinuts Messages postés 5375 Date d'inscription dimanche 4 mai 2003 Statut Modérateur Dernière intervention 14 juin 2023 111
12 oct. 2015 à 12:54
Salut,

Effectivement j'ai adapté le code sans avoir d'ide android sous la main, donc il peut y avoir des erreurs (j'essayerai de le corriger d'ici la fin de semaine si j'ai du temps).

Pour faire simple en JAVA et dans beaucoup d'autres langages, quand on parle de sockets il y OBLIGATOIREMENT, une notion de client/serveur.
Tu dois donc avoir un code qui utilise des BluetoothSocket (le code client), et un autre qui utilise des BluetoothServerSocket pour le socket serveur et des BluetoothSocket qui sont retournés par la méthode accept du serverSocket.


0

Discussions similaires

Créer clic téléchargement fichier pdf android
iKelSilver -
iKelSilver -

14 réponses
Géolocalisation Android
gafsigafsi -
Twinuts -

1 réponse
convertir application php en apk
supreme2014 -
totorino -

3 réponses
création d'une Application Android
EmmanuelNtumba -
NHenry -

6 réponses
comment déployer une application de base de données créee avec delphi7 en utilis
diglas -
diglas -

2 réponses
Rejoignez-nous