当前位置: 首页 > 知识库问答 >
问题:

android中的蓝牙多连接

李勇
2023-03-14

Hy,我们正在通过蓝牙开发android多人游戏。这是一款多人LUDO游戏,其中4名玩家相互连接并进行游戏。

我们被困在第三和第四名球员的连接。

private OnMaxConnectionsReachedListener maxConnectionsListener = new OnMaxConnectionsReachedListener() {
    public void OnMaxConnectionsReached() {

    }
};

private OnIncomingConnectionListener connectedListener = new OnIncomingConnectionListener() {
    public void OnIncomingConnection(String device) {
        //rivalDevice = device;
        if(index < 1000)
        {
            clients[index] = device;
            index++;
            Log.d("Khawar", "Khawar"+device);
            if(index == 1)
            {
                //blue.setText(clients[0]);
                mConnection.sendMessage(clients[0], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]);
            }
            else if(index == 2)
            {
                //blue.setText(clients[0]);
                //red.setText(clients[1]);
                mConnection.sendMessage(clients[0], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]);
                mConnection.sendMessage(clients[1], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]);
            }
            else if(index==3)
            {
                //blue.setText(clients[0]);
                //red.setText(clients[1]);
                //yellow.setText(clients[2]);
                mConnection.sendMessage(clients[0], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]+"--Ludofyp309509--"+clients[2]);
                mConnection.sendMessage(clients[1], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]+"--Ludofyp309509--"+clients[2]);
                mConnection.sendMessage(clients[2], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]+"--Ludofyp309509--"+clients[2]);
            }
        }
        //Toast.makeText(getBaseContext(), "Client found" + device , Toast.LENGTH_LONG).show();
      //  WindowManager w = getWindowManager();
      //  Display d = w.getDefaultDisplay();
       // int width = d.getWidth();
        //int height = d.getHeight();
    }
};

private OnConnectionLostListener disconnectedListener = new OnConnectionLostListener() {
    public void OnConnectionLost(String device) {
        class displayConnectionLostAlert implements Runnable {
            public void run() {
                Builder connectionLostAlert = new Builder(self);

                connectionLostAlert.setTitle("Connection lost");
                connectionLostAlert
                        .setMessage("Your connection with the other player has been lost.");

                connectionLostAlert.setPositiveButton("Ok", new OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        finish();
                    }
                });
                connectionLostAlert.setCancelable(false);
                try {
                connectionLostAlert.show();
                } catch (BadTokenException e){
                    Log.v("TAG", "Exception throws here");
                }
            }
        }
        self.runOnUiThread(new displayConnectionLostAlert());
    }
};

private OnConnectionServiceReadyListener serviceReadyListener = new OnConnectionServiceReadyListener() {
    public void OnConnectionServiceReady() {
        if (mType == 0) {
            mConnection.startServer(1, connectedListener, maxConnectionsListener,
                    dataReceivedListener, disconnectedListener);
            self.setTitle("LudoOverAndroid: " + mConnection.getName() + "-" + mConnection.getAddress());
            server = mConnection.getAddress();
            green.setText(server);
            Log.v("1", server);
      //      Intent Game = new Intent(self, Board.class);
            // .putExtra("TYPE", 1);
        //     startActivity(Game);

        } else {

            self.setTitle("LudoOverAndroid: " + mConnection.getName() + "-" + mConnection.getAddress());
            Intent serverListIntent = new Intent(self, ServerListActivity.class);
            startActivityForResult(serverListIntent, SERVER_LIST_RESULT_CODE);
            clients[index] = mConnection.getAddress();
         //   Intent Game = new Intent(self, Board.class);
            // .putExtra("TYPE", 1);
         //    startActivity(Game);

        }
    }
};

上面是建立连接的示例代码。但是在连接服务类中,我们有以下代码

       public int connect(String srcApp, String device) throws RemoteException {
        if (mApp.length() > 0) {
            Log.v("a", "connection service->connect->mApp.length");
            return Connection.FAILURE;
        }
        mApp = srcApp;
        BluetoothDevice myBtServer = mBtAdapter.getRemoteDevice(device);
        BluetoothSocket myBSock = null;
        Log.v("a", "Yaah aya hay aik baar nahe bar bar :");
        for (int i = 0; i < Connection.MAX_SUPPORTED && myBSock == null; i++) {
            for (int j = 0; j < 3 && myBSock == null; j++) {
                myBSock = getConnectedSocket(myBtServer, mUuid.get(i));
                if (myBSock == null) {
                    try {
                        Log.v("a", "connection service->connect->myBSock==NULL thread sleep");
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        Log.e(TAG, "InterruptedException in connect", e);
                    }
                }
            }
        }
        if (myBSock == null) {
            Log.v("a", "connection service->connect->myBSock==NULLss");
            return Connection.FAILURE;
        }
        mBtSockets.put(device, myBSock);
        mBtDeviceAddresses.add(device);
        Thread mBtStreamWatcherThread = new Thread(new BtStreamWatcher(device));
        mBtStreamWatcherThread.start();
        mBtStreamWatcherThreads.put(device, mBtStreamWatcherThread);
        return Connection.SUCCESS;
    }

当移动设备连接到第三个或第四个设备时,它返回myBSock==null。但是如果代码正常工作,它必须返回设备的地址,并且应该将mBtDeviceAddresses.add(设备);添加到服务器列表中。

请帮助我们解决问题。

提前感谢

共有2个答案

葛承德
2023-03-14

在做了大量工作后,我成功地实现了这一点。在路径中,我遇到了一些棘手的错误,例如,我必须实现握手协议(类似的协议),以避免连接尝试期间出现超时问题。

我开始研究BluetoothChat示例(Android SDK示例),它实现了两个设备之间的通信。所以,我修改了它,允许多个连接。随着代码变得越来越大,我将只告诉您我使用的方法。

基本上,运行我的应用程序的所有设备都可以是服务器或客户端。因此,每个设备都始终有一个BluetoothServerSocket(AcceptThread)在运行,因此通过这种方式,每个设备始终能够接收请求连接。

想要连接的设备启动ConnectThread,此线程在发现过程后启动,或者如果它选择使用getBondedDevices的PairedDevices的BluetoothDevice。

建立连接后,我创建一个表示该连接的新线程(ConnectedThread)。如果你想根据你的设备角色(主或从)有不同的行为,你可以有一个ConnectedThread子类,比如MasterThread和SlaveThread

Android文档很好地解释了如何在以下位置使用蓝牙:http://developer.android.com/guide/topics/connectivity/bluetooth.html

梁骞仕
2023-03-14
package com.switching.bluetooth;

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

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

import com.switching.ServerMainActivity;

/**
 * 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 iBT";
    private static final boolean D = true;

    // Name for the SDP record when creating server socket
    private static final String NAME = "i BT";

    // Unique UUID for this application
    private static UUID MY_UUID;

    // Member fields
    private final BluetoothAdapter mAdapter;
    private final Handler mHandler;
    private AcceptThread mAcceptThread;
    private ConnectThread mConnectThread;
    private ConnectedThread mConnectedThread;
    private int mState;

    private ArrayList<String> mDeviceAddresses;
    private ArrayList<String> mDeviceNames;
    private ArrayList<ConnectedThread> mConnThreads;
    private ArrayList<BluetoothSocket> mSockets;

    /**
     * A bluetooth piconet can support up to 7 connections. This array holds 7
     * unique UUIDs. When attempting to make a connection, the UUID on the
     * client must match one that the server is listening for. When accepting
     * incoming connections server listens for all 7 UUIDs. When trying to form
     * an outgoing connection, the client tries each UUID one at a time.
     */
    private ArrayList<UUID> mUuids;

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

        initializeArrayLists();

        // 7 randomly-generated UUIDs. These must match on both server and
        // client.
        // mUuids.add(UUID.fromString("b7746a40-c758-4868-aa19-7ac6b3475dfc"));
        // mUuids.add(UUID.fromString("2d64189d-5a2c-4511-a074-77f199fd0834"));
        // mUuids.add(UUID.fromString("e442e09a-51f3-4a7b-91cb-f638491d1412"));
        // mUuids.add(UUID.fromString("a81d6504-4536-49ee-a475-7d96d09439e4"));
        // mUuids.add(UUID.fromString("aa91eab1-d8ad-448e-abdb-95ebba4a9b55"));
        // mUuids.add(UUID.fromString("4d34da73-d0a4-4f40-ac38-917e0a9dee97"));
        // mUuids.add(UUID.fromString("5e14d4df-9c8a-4db7-81e4-c937564c86e0"));
    }

    public static UUID getMY_UUID() {
        return MY_UUID;
    }

    public static void setMY_UUID(UUID mY_UUID) {
        MY_UUID = mY_UUID;
    }

    public boolean isDeviceConnectedAtPosition(int position) {
        if (mConnThreads.get(position) == null) {
            return false;
        }
        return true;
    }

    private void initializeArrayLists() {
        mDeviceAddresses = new ArrayList<String>(5);
        mDeviceNames = new ArrayList<String>(5);
        mConnThreads = new ArrayList<ConnectedThread>(5);
        mSockets = new ArrayList<BluetoothSocket>(5);
        mUuids = new ArrayList<UUID>(5);

        for (int i = 0; i < 5; i++) {
            mDeviceAddresses.add(null);
            mDeviceNames.add(null);
            mConnThreads.add(null);
            mSockets.add(null);
            mUuids.add(null);
        }

        Log.i(TAG, "mConnThreads.size() in Service Constructor--"
                + mConnThreads.size());
    }

    public ArrayList<String> getmDeviceNames() {
        return this.mDeviceNames;
    }

    public void setmDeviceNames(ArrayList<String> mDeviceNames) {
        this.mDeviceNames = mDeviceNames;
    }

    public ArrayList<String> getmDeviceAddresses() {
        return mDeviceAddresses;
    }

    public void setmDeviceAddresses(ArrayList<String> mDeviceAddresses) {
        this.mDeviceAddresses = mDeviceAddresses;
    }

    /**
     * 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(ServerMainActivity.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;
        }

        // Start the thread to listen on a BluetoothServerSocket
        if (mAcceptThread == null) {
            mAcceptThread = new AcceptThread();
            mAcceptThread.start();
        }
        setState(STATE_LISTEN);
    }

    /**
     * Start the ConnectThread to initiate a connection to a remote device.
     * 
     * @param device
     *            The BluetoothDevice to connect
     */
    public synchronized void connect(BluetoothDevice device,
            int selectedPosition) {

        if (getPositionIndexOfDevice(device) == -1) {
            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 (mConnThreads.get(selectedPosition) != null) {
                mConnThreads.get(selectedPosition).cancel();
                // mConnectedThread = null;
                mConnThreads.set(selectedPosition, null);
            }

            // Create a new thread and attempt to connect to each UUID
            // one-by-one.
            try {

                // String
                // s="00001101-0000-1000-8000"+device.getAddress().split(":");
                ConnectThread mConnectThread = new ConnectThread(device,
                        UUID.fromString("00001101-0000-1000-8000-"
                                + device.getAddress().replace(":", "")),
                        selectedPosition);
                Log.i(TAG, "uuid-string at server side"
                        + ("00001101-0000-1000-8000" + device.getAddress()
                                .replace(":", "")));
                mConnectThread.start();
                setState(STATE_CONNECTING);
            } catch (Exception e) {
            }
        } else {
            Message msg = mHandler
                    .obtainMessage(ServerMainActivity.MESSAGE_TOAST);
            Bundle bundle = new Bundle();
            bundle.putString(ServerMainActivity.TOAST,
                    "This device " + device.getName() + " Already Connected");
            msg.setData(bundle);
            mHandler.sendMessage(msg);
        }
    }

    /**
     * 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, int selectedPosition) {
        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; }
         * 
         * // Cancel the accept thread because we only want to connect to one //
         * device if (mAcceptThread != null) { mAcceptThread.cancel();
         * mAcceptThread = null; }
         */
        // Start the thread to manage the connection and perform transmissions
        ConnectedThread mConnectedThread = new ConnectedThread(socket);
        mConnectedThread.start();
        // Add each connected thread to an array
        mConnThreads.set(selectedPosition, mConnectedThread);

        // Send the name of the connected device back to the UI Activity
        Message msg = mHandler
                .obtainMessage(ServerMainActivity.MESSAGE_DEVICE_NAME);
        Bundle bundle = new Bundle();
        bundle.putString(ServerMainActivity.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 (mAcceptThread != null) {
            mAcceptThread.cancel();
            mAcceptThread = null;
        }

        for (int i = 0; i < 5; i++) {
            mDeviceNames.set(i, null);
            mDeviceAddresses.set(i, null);
            mSockets.set(i, null);
            if (mConnThreads.get(i) != null) {
                mConnThreads.get(i).cancel();
                mConnThreads.set(i, 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) {
        // When writing, try to write out to all connected threads
        for (int i = 0; i < mConnThreads.size(); i++) {
            try {
                // Create temporary object
                ConnectedThread r;
                // Synchronize a copy of the ConnectedThread
                synchronized (this) {
                    if (mState != STATE_CONNECTED)
                        return;
                    r = mConnThreads.get(i);
                }
                // Perform the write unsynchronized
                r.write(out);
            } catch (Exception e) {
            }
        }
    }

    /**
     * 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(ServerMainActivity.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(ServerMainActivity.TOAST, "Unable to connect device");
        msg.setData(bundle);
        mHandler.sendMessage(msg);

    }

    /**
     * Indicate that the connection was lost and notify the UI Activity.
     */
    private void connectionLost(BluetoothDevice device) {
        // setState(STATE_LISTEN);
        int positionIndex = getPositionIndexOfDevice(device);
        if (positionIndex != -1) {
            Log.i(TAG, "getPositionIndexOfDevice(device) ==="
                    + mDeviceAddresses.get(getPositionIndexOfDevice(device)));
            mDeviceAddresses.set(positionIndex, null);
            mDeviceNames.set(positionIndex, null);
            mConnThreads.set(positionIndex, null);

            Message msg = mHandler
                    .obtainMessage(ServerMainActivity.MESSAGE_TOAST);
            Bundle bundle = new Bundle();
            bundle.putString(ServerMainActivity.TOAST,
                    "Device connection was lost from " + device.getName());
            msg.setData(bundle);
            mHandler.sendMessage(msg);
        }
        // Send a failure message back to the Activity
    }

    private class AcceptThread extends Thread {
        // The local server socket
        private final BluetoothServerSocket mmServerSocket;

        public AcceptThread() {
            BluetoothServerSocket tmp = null;
            // Create a new listening server socket
            try {

                if (mAdapter.isEnabled()) {
                    BluetoothService.setMY_UUID(UUID
                            .fromString("00001101-0000-1000-8000-"
                                    + mAdapter.getAddress().replace(":", "")));
                }
                Log.i(TAG, "MY_UUID.toString()=="
                        + BluetoothService.getMY_UUID().toString());

                tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME,
                        BluetoothService.getMY_UUID());
            } catch (IOException e) {
                Log.e(TAG, "listen() failed", e);
            }
            mmServerSocket = tmp;
        }

        public void run() {
            if (D)
                Log.d(TAG, "BEGIN mAcceptThread" + this);
            setName("AcceptThread");
            BluetoothSocket socket = null;
            Log.i(TAG, "mState in acceptThread==" + mState);
            // Listen to the server socket if we're not connected
            while (mState != STATE_CONNECTED) {
                try {
                    // This is a blocking call and will only return on a
                    // successful connection or an exception
                    socket = mmServerSocket.accept();
                } catch (IOException e) {
                    Log.e(TAG, "accept() failed", e);
                    break;
                }

                // If a connection was accepted
                if (socket != null) {
                    synchronized (BluetoothService.this) {
                        switch (mState) {
                        case STATE_LISTEN:
                        case STATE_CONNECTING:
                            // Situation normal. Start the connected thread.
                            connected(socket, socket.getRemoteDevice(),getAvailablePositionIndexForNewConnection(socket.getRemoteDevice()));
                            break;
                        case STATE_NONE:
                        case STATE_CONNECTED:
                            // Either not ready or already connected. Terminate
                            // new socket.
                            try {
                                socket.close();
                            } catch (IOException e) {
                                Log.e(TAG, "Could not close unwanted socket", e);
                            }
                            break;
                        }
                    }
                }
            }
            if (D)
                Log.i(TAG, "END mAcceptThread");
        }

        public void cancel() {
            if (D)
                Log.d(TAG, "cancel " + this);
            try {
                mmServerSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of server failed", e);
            }
        }
    }

    /**
     * This thread runs while listening for incoming connections. It behaves
     * like a server-side client. It runs until a connection is accepted (or
     * until cancelled).
     */
    // private class AcceptThread extends Thread {
    // BluetoothServerSocket serverSocket = null;
    //
    // public AcceptThread() {
    // }
    //
    // public void run() {
    // if (D)
    // Log.d(TAG, "BEGIN mAcceptThread" + this);
    // setName("AcceptThread");
    // BluetoothSocket socket = null;
    // try {
    // // Listen for all 7 UUIDs
    // serverSocket = mAdapter.listenUsingRfcommWithServiceRecord(
    // NAME, MY_UUID);
    // socket = serverSocket.accept();
    // if (socket != null) {
    // String address = socket.getRemoteDevice().getAddress();
    // mSockets.add(socket);
    // mDeviceAddresses.add(address);
    // mDeviceNames.add(socket.getRemoteDevice().getName());
    // // connected(socket, socket.getRemoteDevice());
    // }
    // } catch (IOException e) {
    // Log.e(TAG, "accept() failed", e);
    // }
    // if (D)
    // Log.i(TAG, "END mAcceptThread");
    // }
    //
    // public void cancel() {
    // if (D)
    // Log.d(TAG, "cancel " + this);
    // try {
    // serverSocket.close();
    // } catch (IOException e) {
    // Log.e(TAG, "close() of server failed", e);
    // }
    // }
    // }

    /**
     * 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;
        private UUID tempUuid;
        private int selectedPosition;

        public ConnectThread(BluetoothDevice device, UUID uuidToTry,
                int selectedPosition) {
            mmDevice = device;
            BluetoothSocket tmp = null;
            tempUuid = uuidToTry;
            this.selectedPosition = selectedPosition;
            // Get a BluetoothSocket for a connection with the
            // given BluetoothDevice
            try {
                tmp = device.createRfcommSocketToServiceRecord(uuidToTry);
            } catch (IOException 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) {
                // if
                // (tempUuid.toString().contentEquals(mUuids.get(6).toString()))
                // {
                connectionFailed();
                // }
                // Close the socket
                try {
                    mmSocket.close();
                } catch (IOException e2) {
                    Log.e(TAG,
                            "unable to close() socket during connection failure",
                            e2);
                }
                // Start the service over to restart listening mode
                BluetoothService.this.start();
                return;
            }

            // Reset the ConnectThread because we're done
            synchronized (BluetoothService.this) {
                mConnectThread = null;
            }
            mDeviceAddresses.set(selectedPosition, mmDevice.getAddress());
            mDeviceNames.set(selectedPosition, mmDevice.getName());
            // Start the connected thread
            connected(mmSocket, mmDevice, selectedPosition);
        }

        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 final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final 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 = new byte[1024];
            int bytes;

            // Keep listening to the InputStream while connected
            while (true) {
                try {
                    // Read from the InputStream
                    bytes = mmInStream.read(buffer);
                    // Send the obtained bytes to the UI Activity
                    mHandler.obtainMessage(
                            ServerMainActivity.MESSAGE_READ,
                            bytes,
                            getPositionIndexOfDevice(mmSocket.getRemoteDevice()),
                            buffer).sendToTarget();
                    Log.i("**********read", "read Called........");
                } catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    connectionLost(mmSocket.getRemoteDevice());
                    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(ServerMainActivity.MESSAGE_WRITE, -1,
                        -1, buffer).sendToTarget();
            } catch (IOException e) {
                Log.e(TAG, "Exception during write", e);
            }
        }

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

    public int getPositionIndexOfDevice(BluetoothDevice device) {
        for (int i = 0; i < mDeviceAddresses.size(); i++) {
            if (mDeviceAddresses.get(i) != null
                    && mDeviceAddresses.get(i).equalsIgnoreCase(
                            device.getAddress()))
                return i;
        }
        return -1;
    }

    public int getAvailablePositionIndexForNewConnection(BluetoothDevice device) {      
        if (getPositionIndexOfDevice(device) == -1) {
            for (int i = 0; i < mDeviceAddresses.size(); i++) {
                if (mDeviceAddresses.get(i) == null) {
                    return i;
                }
            }
        }
        return -1;
    }
}
 类似资料:
  • 问题内容: 我正在开发一个使用蓝牙连接到设备并发送/接收数据的应用程序。我正在使用Nexus One手机进行所有测试。 我从手机到任何设备都无法建立SPP(串行端口)连接。不过,我 已经 能够从一个设备(我的笔记本电脑)连接到使用Mac相当于腻子我的手机(唯一的例外是从市场上的“蓝牙文件传输”应用程序似乎是工作,但我不认为使用RFCOM / SPP …)。 我在LogCat日志中始终看到此消息:

  • 我如何获得Android所有已连接蓝牙设备的列表,而不考虑配置文件? 或者,我看到您可以通过BluetoothManager获取特定配置文件的所有连接设备。获取连接的设备。 我想我可以通过ACTION_ACL_CONNECTED/ACTION_ACL_DISCONNECTED监听连接/断开来查看哪些设备连接...似乎容易出错。 但我想知道是否有更简单的方法来获取所有已连接蓝牙设备的列表。

  • 我有一个android应用程序,它将所有配对的设备放在一个列表视图中。当您单击其中一个列表项时,它将发起连接到该蓝牙设备的请求。 我可以得到设备的列表和他们的地址没有问题。问题是,一旦我尝试连接,我会在socket.connect()上得到一个IOException; 错误消息如下:“连接读取失败,套接字可能关闭或超时,读取RET:-1” 请注意,在“尝试连接到设备”和“连接失败”之间有大约20秒

  • 我正在开发一个蓝牙应用程序来控制Arduino板,但现在我犯了一些错误:当我试图从手机连接时,它会显示一个(没关系)和许多祝酒(它们是从调用的)。BT模块连接到板子是可以的(测试与其他应用程序),所以问题是Java:我不能建立一个连接到我的BT模块。不幸的是,Android Studio没有给我任何日志或错误。这是我的代码:

  • 嗨,我要开发一个应用程序,所以我有一个设备(服务器)与3个客户端。我做了所有的验证,打开蓝牙,找到设备,所有的工作都很好。但当我要连接一个设备时,我不知道会发生什么。 我正在使用下一个代码,当我单击一个我想连接它的设备时。我只有我的应用程序在母设备中。 这里我有一个问题,如果它没有配对会发生什么?如果我尝试连接,它会自动配对吗? 我的UUID是:“00001101-0000-1000-8000-0

  • 我可以在Android中看到蓝牙设备的两种状态。1、配对2。已连接-<我正在尝试在Android系统中使用当前连接的蓝牙设备。但我只从适配器获得配对设备列表。getBondedDevices() 我需要当前连接的设备。我怎么能得到这个。请有人帮我实现这一点。提前谢谢。