Connexion Bluetooth Android avec le périphérique port série

Question

J'ai utilisé la classe BluetoothChatService du programme exemple BluetoothChat pour la connexion Bluetooth. Je l'ai modifié comme

private static final UUID MY_UUID = UUID.fromString ("00001101-0000-1000-8000-00805F9B34FB");

pour le connecter à un périphérique de port série.

Mon exemple de test des appareils Android sont NexusOne, HTC Desire, LG Optimus, Motorola Droid.

Chaque fois que j'utilise mon application pour le connecter à un matériel, il se connecte et se déconnecte de manière appropriée en utilisant NexusOne. Mais lors de l'utilisation d'autres appareils Android parfois ils se connectent, parfois même après avoir essayé des centaines de fois, il ne se connecte pas. Et parfois, quand je me déconnecte, l'application se déconnecte mais le voyant Bluetooth du matériel est allumé, indiquant que la connexion est toujours activée. Je me demande si c'est mon erreur de codage, ou une erreur matérielle, ou une erreur de la bibliothèque Bluetooth OS Android. Je n'ai pas à faire face à ce problème avec NexusOne. Je n'ai pas été en mesure de localiser exactement l'emplacement du problème. Quelqu'un peut-il me signaler ce qui pourrait être la ligne de conduite possible que je devrais prendre pour résoudre ce problème?

---

code qui donne "Impossible de connecter un appareil" Toast message

/**

* Constructor. Prepares a new BluetoothChat session. 

* @param context The UI Activity Context 

* @param handler A Handler to send messages back to the UI Activity 

*/ 


public BluetoothChatService(Context context, Handler handler) { 
    mAdapter = BluetoothAdapter.getDefaultAdapter(); 
    mState = STATE_NONE; 
    mHandler = handler; 
} 

/** 
* Set the current state of the chat 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(BluetoothChat.MESSAGE_STATE_CHANGE, state, -1).sendToTarget(); 
} 

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

/** 
* Start the chat service. Specifically start AcceptThread to begin a 
* session in listening (server) mode. Called by the Activity onResume() */ 
public synchronized void start() { 
    if (D) Log.d(TAG, "start"); 

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

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

    setState(STATE_LISTEN); 

    // Start the thread to listen on a BluetoothServerSocket 
    if (mSecureAcceptThread == null) { 
     mSecureAcceptThread = new AcceptThread(true); 
     mSecureAcceptThread.start(); 
    } 
    if (mInsecureAcceptThread == null) { 
     mInsecureAcceptThread = new AcceptThread(false); 
     mInsecureAcceptThread.start(); 
    } 
} 

/** 
* Start the ConnectThread to initiate a connection to a remote device. 
* @param device The BluetoothDevice to connect 
* @param secure Socket Security type - Secure (true) , Insecure (false) 
*/ 
public synchronized void connect(BluetoothDevice device, boolean secure) { 
    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, secure); 
    mConnectThread.start(); 
    setState(STATE_CONNECTING); 
} 

/** 
* 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, final String socketType) { 
    if (D) Log.d(TAG, "connected, Socket Type:" + socketType); 

    // 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;} 

    // Cancel the accept thread because we only want to connect to one device 
    if (mSecureAcceptThread != null) { 
     mSecureAcceptThread.cancel(); 
     mSecureAcceptThread = null; 
    } 
    if (mInsecureAcceptThread != null) { 
     mInsecureAcceptThread.cancel(); 
     mInsecureAcceptThread = null; 
    } 

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

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

    setState(STATE_CONNECTED); 
} 

/** 
* Stop all threads 
*/ 
public synchronized void stop() { 
    if (D) Log.d(TAG, "stop"); 

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

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

    if (mSecureAcceptThread != null) { 
     mSecureAcceptThread.cancel(); 
     mSecureAcceptThread = null; 
    } 

    if (mInsecureAcceptThread != null) { 
     mInsecureAcceptThread.cancel(); 
     mInsecureAcceptThread = null; 
    } 
    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) { 
     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() { 
    // Send a failure message back to the Activity 
    Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST); 
    Bundle bundle = new Bundle(); 
    bundle.putString(BluetoothChat.TOAST, "Unable to connect device"); 
    msg.setData(bundle); 
    mHandler.sendMessage(msg); 

    // Start the service over to restart listening mode 
    BluetoothChatService.this.start(); 
} 

/** 
* Indicate that the connection was lost and notify the UI Activity. 
*/ 
private void connectionLost() { 
    // Send a failure message back to the Activity 
    Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST); 
    Bundle bundle = new Bundle(); 
    bundle.putString(BluetoothChat.TOAST, "Device connection was lost"); 
    msg.setData(bundle); 
    mHandler.sendMessage(msg); 

    // Start the service over to restart listening mode 
    BluetoothChatService.this.start(); 
} 

Answer 1

Eh bien, le code a eu quelques erreurs ... ils ont été résolus une fois que je suis allé sur le cycle de vie complet de l'activité et mis en œuvre en fonction de cela. La classe donnée est bien.

Answer 2

Est-ce que l'UUID utilisé pour le code du serveur écrit pour le "matériel sur mesure" , correspond à l'UUID utilisé sur le téléphone Android? Il se peut que le Nexus One soit le seul téléphone (parmi vos téléphones) qui utilise Gingerbread (?) Et qui signifie un niveau d'API plus élevé que les versions précédentes d'Android. Parcourez les journaux de changement de Gingerbread relatifs à Bluetooth. Ce serait probablement la raison.