Bluetooth with Android Service Discovery Failed

I have a problem with bluetooth in Android, I follow the tutorial in the android developer but I am not able to connect to a paired device in Android, I am using android Studio and this is my code:

public class BluetootConectionManager { private static final String TAG = "BLUETOOTH CONECTION"; public static BluetootConectionManager BLUETOOTH_MANAGER= new BluetootConectionManager();

private BluetoothStateListener mBluetoothStateListener = null;

// Unique UUID for this application
private static final UUID UUID_OTHER_DEVICE = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb");

private ConnectThread mConnectThread;
private AcceptThread mSecureAcceptThread;

private static final String NAME_SECURE = "Bluetooth Secure";

private ConnectedThread mConnectedThread;
private BluetoothAdapter mAdapter;

private int mState;

public interface BluetoothStateListener
{
    public void onServiceStateChanged(int state);
}

public BluetootConectionManager()
{
    mAdapter = BluetoothAdapter.getDefaultAdapter();
    mState = BluetoothState.STATE_NONE;
    mAdapter = BluetoothAdapter.getDefaultAdapter();
}

public void setBluetoothStateListener(BluetoothStateListener listener)
{
    this.mBluetoothStateListener = listener;
}


public String[] getPairedDeviceName() {
    int c = 0;
    Set<BluetoothDevice> devices = mAdapter.getBondedDevices();
    String[] name_list = new String[devices.size()];
    for(BluetoothDevice device : devices) {
        name_list[c] = device.getName();
        c++;
    }
    return name_list;
}

public String[] getPairedDeviceAddress() {
    int c = 0;
    Set<BluetoothDevice> devices = mAdapter.getBondedDevices();
    String[] address_list = new String[devices.size()];
    for(BluetoothDevice device : devices) {
        address_list[c] = device.getAddress();
        c++;
    }
    return address_list;
}



public synchronized int getState()
{
    return mState;
}

// CONECTAR CON DISPOSITIVOS
public synchronized void connect(String address)
{
    BluetoothDevice device = mAdapter.getRemoteDevice(address);
    connect(device);
}


public synchronized void connect(BluetoothDevice device)
{
    // Cancel any thread attempting to make a connection
    if (mState == BluetoothState.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(BluetoothState.STATE_CONNECTING);
}

// METODO PARA OBTENER CONEXIONES ENTRANTES
public synchronized void start()
{
    if (mConnectThread != null)
    {
        mConnectThread.cancel();
        mConnectThread = null;
    }
    // Cancel any thread currently running a connection
    if (mConnectedThread != null)
    {
        mConnectedThread.cancel();
        mConnectedThread = null;
    }

    setState(BluetoothState.STATE_LISTEN);
    if (mSecureAcceptThread == null) {
        mSecureAcceptThread = new AcceptThread();
        mSecureAcceptThread.start();
    }
}

public synchronized void stop() {
    if (mConnectThread != null) {
        mConnectThread.cancel();
        mConnectThread = null;
    }

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

    if (mSecureAcceptThread != null) {
        mSecureAcceptThread.cancel();
        mSecureAcceptThread.kill();
        mSecureAcceptThread = null;
    }
    setState(BluetoothState.STATE_NONE);

}


public void send(byte[] data, boolean CRLF) {
    if(getState() == BluetoothState.STATE_CONNECTED) {
        if(CRLF) {
            byte[] data2 = new byte[data.length + 2];
            for(int i = 0 ; i < data.length ; i++)
                data2[i] = data[i];
            data2[data2.length - 0] = 0x0A;
            data2[data2.length] = 0x0D;
            write(data2);
        } else {
            write(data);
        }
    }
}

public void send(String data, boolean CRLF) {
    if(getState() == BluetoothState.STATE_CONNECTED) {
        if(CRLF)
            data += "rn";
        write(data.getBytes());
    }
}




private void write(byte[] out) {
    // Create temporary object
    ConnectedThread r;
    // Synchronize a copy of the ConnectedThread
    synchronized (this) {
        if (mState != BluetoothState.STATE_CONNECTED) return;
        r = mConnectedThread;
    }
    // Perform the write unsynchronized
    r.write(out);
}


private void connectionFailed() {
    // Start the service over to restart listening mode
    BluetootConectionManager.this.start();
}

// Indicate that the connection was lost and notify the UI Activity
private void connectionLost() {
    // Start the service over to restart listening mode
    BluetootConectionManager.this.start();
}

private synchronized void setState(int state)
{
    mState = state;
    // Give the new state to the Handler so the UI Activity can update
    mBluetoothStateListener.onServiceStateChanged(state);
}


// session in listening (server) mode. Called by the Activity onResume()


private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;

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

        // Get a BluetoothSocket for a connection with the
        // given BluetoothDevice
        try
        {
            tmp = device.createRfcommSocketToServiceRecord(UUID_OTHER_DEVICE);
        } catch (IOException e)
        {
            e.printStackTrace();
        }
        mmSocket = tmp;
    }

    public void run() {
        // 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) {
            // Close the socket
            e.printStackTrace();
            try {
                mmSocket.close();
            } catch (IOException e2)
            {
                e.printStackTrace();
            }
            connectionFailed();
            return;
        }

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


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

    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}

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

    if (mSecureAcceptThread != null) {
        mSecureAcceptThread.cancel();
        mSecureAcceptThread = 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

    setState(BluetoothState.STATE_CONNECTED);
}

// 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)
    {
        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) { }

        mmInStream = tmpIn;
        mmOutStream = tmpOut;

    }

    public void run() {

        byte[] buffer;
        ArrayList<Integer> arr_byte = new ArrayList<Integer>();

        // Keep listening to the InputStream while connected
        while (true) {
            try {
                int data = mmInStream.read();
                if(data == 0x0A) {
                } else if(data == 0x0D) {
                    buffer = new byte[arr_byte.size()];
                    for(int i = 0 ; i < arr_byte.size() ; i++) {
                        buffer[i] = arr_byte.get(i).byteValue();
                    }
                    // Send the obtained bytes to the UI A
                    arr_byte = new ArrayList<Integer>();
                } else {
                    arr_byte.add(data);
                }
            } catch (IOException e) {
                connectionLost();
                // Start the service over to restart listening mode
                BluetootConectionManager.this.start();
                break;
            }
        }
    }

    // Write to the connected OutStream.
    // @param buffer  The bytes to write
    public void write(byte[] buffer) {
        try {/*
            byte[] buffer2 = new byte[buffer.length + 2];
            for(int i = 0 ; i < buffer.length ; i++)
                buffer2[i] = buffer[i];
            buffer2[buffer2.length - 2] = 0x0A;
            buffer2[buffer2.length - 1] = 0x0D;*/
            mmOutStream.write(buffer);
            // Share the sent message back to the UI Activity
        } catch (IOException e) { }
    }

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

private class AcceptThread extends Thread {
    // The local server socket
    private BluetoothServerSocket mmServerSocket;
    private String mSocketType;
    boolean isRunning = true;

    public AcceptThread() {
        BluetoothServerSocket tmp = null;

        // Create a new listening server socket
        try {
            tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, UUID_OTHER_DEVICE);
        } catch (IOException e) { }
        mmServerSocket = tmp;
    }

    public void run() {
        setName("AcceptThread" + mSocketType);
        BluetoothSocket socket = null;

        // Listen to the server socket if we're not connected
        while (mState != BluetoothState.STATE_CONNECTED && isRunning) {
            try {
                // This is a blocking call and will only return on a
                // successful connection or an exception
                socket = mmServerSocket.accept();
            } catch (IOException e) {
                break;
            }

            // If a connection was accepted
            if (socket != null) {
                synchronized (BluetootConectionManager.this) {
                    switch (mState) {
                        case BluetoothState.STATE_LISTEN:
                        case BluetoothState.STATE_CONNECTING:
                            // Situation normal. Start the connected thread.
                            connected(socket, socket.getRemoteDevice());
                            break;
                        case BluetoothState.STATE_NONE:
                        case BluetoothState.STATE_CONNECTED:
                            // Either not ready or already connected. Terminate new socket.
                            try {
                                socket.close();
                            } catch (IOException e) { }
                            break;
                    }
                }
            }
        }
    }

    public void cancel() {
        try {
            mmServerSocket.close();
            mmServerSocket = null;
        } catch (IOException e) { }
    }

    public void kill() {
        isRunning = false;
    }
}

}

Im am trying to connect with

btManager.connect(address);

but I get the following error when trying to connect:

java.io.IOException: Service discovery failed

Gracias por ayudarme a resolver este problema

链接地址: http://www.djcxy.com/p/82018.html

上一篇: 自定义存储库在自定义约束验证器中为空

下一篇: 带有Android服务发现的蓝牙失败