Comment déconnecter une connexion Bluetooth (HTC Desire)

Question

Je dois connecter mon android à un périphérique Bluetooth. J'utilise l'exemple BluetoothChat de Google.

J'ai eu quelques problèmes pour faire cela avec un Google Nexus, parce que le Nexus faisait la connexion mais se déconnecte juste après. J'ai besoin d'initier deux fois la connexion comme solution de contournement (voir connectionLost()).

Maintenant, cela fonctionne bien sur le Nexus One et sur le HTC Desire aussi.

Mon problème est la déconnexion à la sortie de l'application. Cela fonctionne très bien sur le Nexus, la connexion est fermée, mais pas sur le HTC Desire. J'ajoute la fonction de fermeture inputtream/sortiestream en plus de la fermeture du socket. Jetez un oeil à la fonction "stop()".

package xxx.yyy.zzz; 

import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.lang.reflect.Method; 
import java.util.UUID; 

import activities.Act_Main; 

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

/** 
* This class does all the work for setting up and managing Bluetooth 
* connections with other devices. It has a thread that listens for 
* incoming connections, a thread for connecting with a device, and a 
* thread for performing data transmissions when connected. 
*/ 
public class BluetoothService { 
    // Debugging 
    private static final String TAG = "BluetoothService"; 
    private static final boolean D = true; 

    // Member fields 
    //private final BluetoothAdapter mAdapter; 
    private final Handler mHandler; 
    private ConnectThread mConnectThread; 
    private ConnectedThread mConnectedThread; 
    private int mState; 
    private String mBTAddress; 
    private boolean isStop = false; 

    // Constants that indicate the current connection state 
    public static final int STATE_NONE = 0;  // we're doing nothing 
    public static final int STATE_LISTEN = 1;  // now listening for incoming connections 
    public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection 
    public static final int STATE_CONNECTED = 3; // now connected to a remote device 

    /** 
    * Constructor. Prepares a new Act_Main session. 
    * @param context The UI Activity Context 
    * @param handler A Handler to send messages back to the UI Activity 
    */ 
    public BluetoothService(Context context, Handler handler) 
    { 
     //mAdapter = BluetoothAdapter.getDefaultAdapter(); 
     mState = STATE_NONE; 
     mHandler = handler; 
    } 

    /** 
    * Set the current state of the connection 
    * @param state An integer defining the current connection state 
    */ 
    private synchronized void setState(int state) 
    { 
     if (D) Log.d(TAG, "setState() " + mState + " -> " + state); 
     mState = state; 

     // Give the new state to the Handler so the UI Activity can update 
     mHandler.obtainMessage(Act_Main.MESSAGE_STATE_CHANGE, state, -1).sendToTarget(); 
    } 

    /** 
    * Return the current connection state. */ 
    public synchronized int getState() 
    { 
     return mState; 
    } 

    /** 
    * Start the ConnectThread to initiate a connection to a remote device. 
    * @param device The BluetoothDevice to connect 
    */ 
    public synchronized void connect(String BTAddress) 
    { 
     mBTAddress = BTAddress ; 

     // Get the BLuetoothDevice object 
     BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(BTAddress); 

     if (D) Log.d(TAG, "connect to: " + device); 

     // Cancel any thread attempting to make a connection 
     if (mState == STATE_CONNECTING) 
      if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;} 

     // Cancel any thread currently running a connection 
     if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;} 

     // Start the thread to connect with the given device 
     mConnectThread = new ConnectThread(device); 
     mConnectThread.start(); 
     setState(STATE_CONNECTING); 
     isStop = false ; 
    } 

    /** 
    * Start the ConnectedThread to begin managing a Bluetooth connection 
    * @param socket The BluetoothSocket on which the connection was made 
    * @param device The BluetoothDevice that has been connected 
    */ 
    public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) 
    { 
     if (D) Log.d(TAG, "connected"); 

     // Cancel the thread that completed the connection 
     if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;} 

     // Cancel any thread currently running a connection 
     if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;} 

     // Start the thread to manage the connection and perform transmissions 
     mConnectedThread = new ConnectedThread(socket); 
     mConnectedThread.start(); 

     // Send the name of the connected device back to the UI Activity 
     Message msg = mHandler.obtainMessage(Act_Main.MESSAGE_DEVICE_NAME); 
     Bundle bundle = new Bundle(); 
     bundle.putString(Act_Main.DEVICE_NAME, device.getName()); 
     msg.setData(bundle); 
     mHandler.sendMessage(msg); 

     setState(STATE_CONNECTED); 
    } 

    /** 
    * Stop all threads 
    */ 
    public synchronized void stop() 
    { 
     isStop = true ; 

     if (D) 
      Log.d(TAG, "stop"); 

     if(mConnectThread != null) 
     { 
      mConnectThread.cancel(); 
      Thread moribund = mConnectThread; 
      mConnectThread = null; 
      moribund.interrupt(); 
     } 

     if(mConnectedThread != null) 
     { 
      mConnectedThread.cancel(); 
      Thread moribund = mConnectedThread; 
      mConnectedThread = null; 
      moribund.interrupt(); 
     } 

     setState(STATE_NONE); 
    } 

    /** 
    * Write to the ConnectedThread in an unsynchronized manner 
    * @param out The bytes to write 
    * @see ConnectedThread#write(byte[]) 
    */ 
    public void write(byte[] out) 
    { 
     // Create temporary object 
     ConnectedThread r; 

     // Synchronize a copy of the ConnectedThread 
     synchronized (this) 
     { 
      Log.d(TAG, "BT_SEND_MESSAGE"); 

      if (mState != STATE_CONNECTED) 
       return; 

      r = mConnectedThread; 
     } 

     // Perform the write unsynchronized 
     r.write(out); 
    } 

    /** 
    * Indicate that the connection attempt failed and notify the UI Activity. 
    */ 
    private void connectionFailed() 
    { 
     try 
     { 
      synchronized (this) 
      { 
       this.wait(3000); 
      } 
      connect(mBTAddress); 
     } 
     catch(InterruptedException ex) 
     { 
      Log.e(TAG, "WAIT_EXCEPTION:"+ ex.getMessage()); 
     } 
    } 

    /** 
    * Indicate that the connection was lost and notify the UI Activity. 
    */ 
    private void connectionLost() 
    { 
     if (!isStop) 
      connect(mBTAddress); 
    } 

    /** 
    * This thread runs while attempting to make an outgoing connection 
    * with a device. It runs straight through; the connection either 
    * succeeds or fails. 
    */ 
    private class ConnectThread extends Thread 
    { 
     private final BluetoothSocket mmSocket; 
     private final BluetoothDevice mmDevice; 

     public ConnectThread(BluetoothDevice device) 
     { 
      mmDevice = device; 
      BluetoothSocket tmp = null; 

      // Get a BluetoothSocket for a connection with the 
      // given BluetoothDevice 
      try 
      { 
       tmp = device.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")); 
      } 
      catch (Exception e) 
      { 
       Log.e(TAG, "create() failed", e); 
      } 
      mmSocket = tmp; 
     } 

     public void run() 
     { 
      Log.i(TAG, "BEGIN mConnectThread"); 
      setName("ConnectThread"); 

      // Always cancel discovery because it will slow down a connection 
      //mAdapter.cancelDiscovery(); 

      // Make a connection to the BluetoothSocket 
      try 
      { 
       // This is a blocking call and will only return on a successful connection or an exception 
       mmSocket.connect(); 
      } 
      catch (IOException e) 
      { 
       connectionFailed(); 

       // Close the socket 
       try 
       { 
        mmSocket.close(); 
       } 
       catch (IOException e2) 
       { 
        Log.e(TAG, "unable to close() socket during connection failure", e2); 
       } 
       return; 
      } 

      // Reset the ConnectThread because we're done 
      synchronized (BluetoothService.this) 
      { 
       mConnectThread = null; 
      } 

      // Start the connected thread 
      connected(mmSocket, mmDevice); 
     } 

     public void cancel() 
     { 
      try 
      { 
       mmSocket.close(); 
      } 
      catch (IOException e) 
      { 
       Log.e(TAG, "close() of connect socket failed", e); 
      } 
     } 
    } 

    /** 
    * This thread runs during a connection with a remote device. 
    * It handles all incoming and outgoing transmissions. 
    */ 
    private class ConnectedThread extends Thread { 
     private BluetoothSocket mmSocket; 
     private InputStream mmInStream; 
     private OutputStream mmOutStream; 

     public ConnectedThread(BluetoothSocket socket) { 
      Log.d(TAG, "create ConnectedThread"); 
      mmSocket = socket; 
      InputStream tmpIn = null; 
      OutputStream tmpOut = null; 

      // Get the BluetoothSocket input and output streams 
      try { 
       tmpIn = socket.getInputStream(); 
       tmpOut = socket.getOutputStream(); 
      } catch (IOException e) { 
       Log.e(TAG, "temp sockets not created", e); 
      } 

      mmInStream = tmpIn; 
      mmOutStream = tmpOut; 
     } 

     public void run() 
     { 
      Log.i(TAG, "BEGIN mConnectedThread"); 
      byte[] buffer; 
      int bytes = 0; 

      // Keep listening to the InputStream while connected 
      while (true) 
      { 
       try 
       { 
        //Clear buffer 
        buffer = new byte[1024]; 

        // Read from the InputStream 
        bytes = mmInStream.read(buffer); 

        // Send the obtained bytes to the UI Activity 
        mHandler.obtainMessage(Act_Main.MESSAGE_READ, bytes, -1, buffer).sendToTarget(); 
       } 
       catch (IOException e) 
       { 
        //String bufferStr = new String(buffer, 0, buffer.length); 
        Log.e(TAG, "disconnected", e); 
        connectionLost(); 
        break; 
       } 
      } 
     } 

     /** 
     * Write to the connected OutStream. 
     * @param buffer The bytes to write 
     */ 
     public void write(byte[] buffer) 
     { 
      try 
      { 
       mmOutStream.write(buffer); 
      } 
      catch (IOException e) 
      { 
       Log.e(TAG, "Exception during write", e); 
      } 
     } 

     public void cancel() 
     { 
      if (mmOutStream != null) 
      { 
       try {mmOutStream.close();} catch (Exception e) { Log.e(TAG, "close() of outputstream failed", e); } 
       mmOutStream = null; 
      } 

      if (mmInStream != null) 
      { 
       try {mmInStream.close();} catch (Exception e) { Log.e(TAG, "close() of inputstream failed", e); } 
       mmInStream = null; 
      } 

      if (mmSocket != null) 
      { 
       try {mmSocket.close();} catch (Exception e) { Log.e(TAG, "close() of connect socket failed", e); } 
       mmSocket = null; 
      } 
     } 
    } 
} 

Merci d'avance pour votre aide.

JJ

Answer 1

commentaire rapide sur la synchronisation dans votre code:

Laissez le mot-clé synchronized sur votre méthode connect(), mais quand vient le temps de se connecter, appelez votre connect() d'un fil, plutôt que de créer un fil de votre connect() . À l'heure actuelle, votre code déclenche un thread de connexion à partir de connect() et en vain l'objectif de la synchronisation. (Le but étant de synchroniser les requêtes à connect() afin que plusieurs threads ne soient pas mélangés car ils essaient de connect en même temps). Cela peut causer certains de vos problèmes de connexion.

en ce qui concerne le HTC:

Je pense que vous et j'ai rencontré le même problème: Why can't HTC Droid running OTA 2.1 communicate with RFCOMM?

Une note sur la déconnexion d'une connexion Bluetooth:

Assurez-vous de déconnecter gracieusement chaque fois en utilisant votre méthode cancel().

Answer 2

Je viens de lire ce post maintenant: Bluetooth on 2.0+

Quelqu'un at-il une solution à la mauvaise mise en œuvre du HTC Desire? MISE À JOUR: Par exemple, j'ai fait une très mauvaise solution de contournement. Je tue le processus lorsque je quitte l'application:

ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE); 
am.restartPackage("com.example.package"); 

J'attends toujours une solution plus propre.

Answer 3

MISE À JOUR: Il semble HTC fixe à travers leur mise à jour Froyo (Android 2.2)