UUID bluetooth et les appareils android

Je suis en train de développer une application pour appareils Android qui permet de connecter deux appareils, mais le problème est que je ne peux connecter (via Bluetooth) avec de Bluetooth de PC ou des appareils avec un autre OS qu'Android.

Je pense que le problème est l'UUID, en ce moment je suis en utilisant, dans BluetoothCommandService.java:

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

Et puis:

    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(MY_UUID);
        } catch (IOException e) {
            Log.e(LOG_TAG, "create() failed", e);
        }
        mmSocket = tmp;
    }

De toute façon je laisse ici tout le code concernant la BluetoothCommandService.java:

    package com.example.vista;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;
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.telephony.TelephonyManager;
import android.util.Log;
public class BluetoothCommandService {
//Debugging
private static final String LOG_TAG = "BluetoothCommandService";
private static final boolean DEBUG = true;
//Unique UUID for this application
private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb");
/*TelephonyManager tManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String uuid = tManager.getDeviceId();*/
//Member fields
private final BluetoothAdapter mAdapter;
private final Handler mHandler;
private ConnectThread mConnectThread;
private ConnectedThread mConnectedThread;
private int mState;
//   private BluetoothDevice mSavedDevice;
//   private int mConnectionLostCount;
//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
//Constants that indicate command to computer
public static final int EXIT_CMD = -1;
public static final int VOL_UP = 1;
public static final int VOL_DOWN = 2;
public static final int MOUSE_MOVE = 3;
/**
* 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 BluetoothCommandService(Context context, Handler handler) {
if (DEBUG) Log.e(LOG_TAG, "BluetoothCommandService");
mAdapter = BluetoothAdapter.getDefaultAdapter();
mState = STATE_NONE;
//mConnectionLostCount = 0;
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 (DEBUG) Log.e(LOG_TAG, "setState() " + mState + " -> " + state);
mState = state;
//Give the new state to the Handler so the UI Activity can update
mHandler.obtainMessage(Buscarpartida.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
}
/**
* Return the current connection state. */
public synchronized int getState() {
Log.e(LOG_TAG, "MSTATE "+ mState);
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 (DEBUG) Log.e(LOG_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_NONE);
Log.e(LOG_TAG, "start fin "+ mState);
}
/**
* Start the ConnectThread to initiate a connection to a remote device.
* @param device  The BluetoothDevice to connect
*/
public synchronized void connect(BluetoothDevice device) {
if (DEBUG) Log.e(LOG_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);
}
/**
* 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) {
//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(Buscarpartida.MESSAGE_DEVICE_NAME);
Bundle bundle = new Bundle();
bundle.putString(Buscarpartida.DEVICE_NAME, device.getName());
msg.setData(bundle);
mHandler.sendMessage(msg);
setState(STATE_CONNECTED);
}
/**
* Stop all threads
*/
public synchronized void stop() {
if (DEBUG) Log.e(LOG_TAG, "stop");
if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
setState(STATE_NONE);
if (DEBUG) Log.e(LOG_TAG, "stop fin "+ mState);
}
/**
* 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);
}
public void write(int 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() {
setState(STATE_LISTEN);
//Send a failure message back to the Activity
Message msg = mHandler.obtainMessage(Buscarpartida.MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(Buscarpartida.TOAST, "Imposible Conectar");
msg.setData(bundle);
mHandler.sendMessage(msg);
}
/**
* Indicate that the connection was lost and notify the UI Activity.
*/
private void connectionLost() {
//       mConnectionLostCount++;
//       if (mConnectionLostCount < 3) {
//         //Send a reconnect message back to the Activity
//         Message msg = mHandler.obtainMessage(Main.MESSAGE_TOAST);
//         Bundle bundle = new Bundle();
//         bundle.putString(Main.TOAST, "Device connection was lost. Reconnecting...");
//         msg.setData(bundle);
//         mHandler.sendMessage(msg);
//         
//         connect(mSavedDevice);      
//       } else {
setState(STATE_LISTEN);
//Send a failure message back to the Activity
Message msg = mHandler.obtainMessage(Buscarpartida.MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(Buscarpartida.TOAST, "Conexion Perdida");
msg.setData(bundle);
mHandler.sendMessage(msg);
//       }
}
/**
* 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(MY_UUID);
} catch (IOException e) {
Log.e(LOG_TAG, "create() failed", e);
}
mmSocket = tmp;
}
public void run() {
setName("ConnectThread");
//Always cancel discovery because it will slow down a connection
mAdapter.cancelDiscovery();
Log.e(LOG_TAG, "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();
Log.e(LOG_TAG, "mmSocket.connect()");
} catch (IOException e) {
connectionFailed();
Log.e(LOG_TAG, " connectionFailed()");
//Close the socket
try {
mmSocket.close();
} catch (IOException e2) {
Log.e(LOG_TAG, "unable to close() socket during connection failure", e2);
}
//Start the service over to restart listening mode
Log.e(LOG_TAG, "run2()");
BluetoothCommandService.this.start();
return;
}
//Reset the ConnectThread because we're done
synchronized (BluetoothCommandService.this) {
mConnectThread = null;
}
//Start the connected thread
connected(mmSocket, mmDevice);
}
public void cancel() {
try {
mmSocket.close();
} catch (IOException e) {
Log.e(LOG_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 final BluetoothSocket mmSocket;
private final InputStream mmInStream;
private final OutputStream mmOutStream;
public ConnectedThread(BluetoothSocket socket) {
Log.e(LOG_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(LOG_TAG, "temp sockets not created", e);
}
mmInStream = tmpIn;
mmOutStream = tmpOut;
}
public void run() {
Log.e(LOG_TAG, "runrer");
byte[] buffer = new byte[1024];
//Keep listening to the InputStream while connected
while (true) {
try {
//Read from the InputStream
int bytes = mmInStream.read(buffer);
//Send the obtained bytes to the UI Activity
mHandler.obtainMessage(Buscarpartida.MESSAGE_READ, bytes, -1, buffer)
.sendToTarget();
} catch (IOException e) {
Log.e(LOG_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);
//Share the sent message back to the UI Activity
//               mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer)
//                       .sendToTarget();
} catch (IOException e) {
Log.e(LOG_TAG, "Exception during write", e);
}
}
public void write(int out) {
try {
mmOutStream.write(out);
//Share the sent message back to the UI Activity
//               mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer)
//                       .sendToTarget();
} catch (IOException e) {
Log.e(LOG_TAG, "Exception during write", e);
}
}
public void cancel() {
try {
mmOutStream.write(EXIT_CMD);
mmSocket.close();
} catch (IOException e) {
Log.e(LOG_TAG, "close() of connect socket failed", e);
}
}
}
}

Merci beaucoup!

OriginalL'auteur AbAetherno | 2013-04-28