import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothSocket; import android.os.Handler; import android.os.Message; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.UUID; public class bluetoothController { private BluetoothAdapter mBluetoothAdapter; private BluetoothSocket mBluetoothSocket; private InputStream mInputStream; private OutputStream mOutputStream; private Handler mHandler; public bluetoothController(Handler handler) { mHandler = handler; mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); } public boolean connect(String address) { BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address); UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); try { mBluetoothSocket = device.createRfcommSocketToServiceRecord(uuid); mBluetoothSocket.connect(); mInputStream = mBluetoothSocket.getInputStream(); mOutputStream = mBluetoothSocket.getOutputStream(); return true; } catch (IOException e) { e.printStackTrace(); return false; } } public void disconnect() { try { mBluetoothSocket.close(); } catch (IOException e) { e.printStackTrace(); } } public void write(byte[] bytes) { try { mOutputStream.write(bytes); } catch (IOException e) { e.printStackTrace(); } } public void read() { byte[] buffer = new byte[1024]; int bytes; while (true) { try { bytes = mInputStream.read(buffer); String message = new String(buffer, 0, bytes); Message msg = mHandler.obtainMessage(0, message); mHandler.sendMessage(msg); } catch (IOException e) { e.printStackTrace(); break; } } } }

这是一个蓝牙控制器的 Java 类，它可以连接到指定的蓝牙设备并发送和接收数据。它使用 BluetoothAdapter、BluetoothDevice 和 BluetoothSocket 类来管理蓝牙连接，使用 InputStream 和 OutputStream 类来读写数据。它还使用 Handler 和 Message 类来处理接收到的数据。如果你有任何关于这个类的问题，可以继续问我。

相关问题

android 蓝牙通信代码,Android蓝牙通信代码

好的，以下是一个简单的 Android 蓝牙通信代码示例：

首先，你需要在你的 AndroidManifest.xml 文件中添加以下权限：

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

然后，你需要在你的 Activity 中实现蓝牙通信的逻辑。示例代码如下：

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

import androidx.appcompat.app.AppCompatActivity;

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

public class BluetoothActivity extends AppCompatActivity {

    // 蓝牙适配器
    BluetoothAdapter mBluetoothAdapter;
    // 蓝牙设备
    BluetoothDevice mBluetoothDevice;
    // 蓝牙套接字
    BluetoothSocket mBluetoothSocket;
    // 输入流
    InputStream mInputStream;
    // 输出流
    OutputStream mOutputStream;
    // 读取的数据
    String mReadData;
    // 读取数据的线程
    ReadThread mReadThread;

    // 服务端 UUID
    UUID mServerUUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

    Button mConnectButton;
    Button mSendButton;
    EditText mEditText;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_bluetooth);

        mConnectButton = findViewById(R.id.connect_button);
        mSendButton = findViewById(R.id.send_button);
        mEditText = findViewById(R.id.edit_text);

        mConnectButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 检查是否支持蓝牙
                mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
                if (mBluetoothAdapter == null) {
                    Log.e("BluetoothActivity", "设备不支持蓝牙");
                    return;
                }

                // 检查蓝牙是否已开启
                if (!mBluetoothAdapter.isEnabled()) {
                    Log.e("BluetoothActivity", "蓝牙未开启");
                    return;
                }

                // 获取蓝牙设备
                mBluetoothDevice = mBluetoothAdapter.getRemoteDevice("设备的 MAC 地址");

                try {
                    // 创建蓝牙套接字
                    mBluetoothSocket = mBluetoothDevice.createRfcommSocketToServiceRecord(mServerUUID);
                    // 连接蓝牙设备
                    mBluetoothSocket.connect();
                    // 获取输入流
                    mInputStream = mBluetoothSocket.getInputStream();
                    // 获取输出流
                    mOutputStream = mBluetoothSocket.getOutputStream();
                    // 启动读取数据的线程
                    mReadThread = new ReadThread();
                    mReadThread.start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });

        mSendButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 发送数据
                String sendData = mEditText.getText().toString();
                try {
                    mOutputStream.write(sendData.getBytes());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    // 读取数据的线程
    class ReadThread extends Thread {
        @Override
        public void run() {
            byte[] buffer = new byte[1024];
            int bytes;
            while (true) {
                try {
                    // 读取数据
                    bytes = mInputStream.read(buffer);
                    mReadData = new String(buffer, 0, bytes);
                    // 将读取的数据发送给主线程处理
                    mHandler.obtainMessage(1, mReadData).sendToTarget();
                } catch (IOException e) {
                    e.printStackTrace();
                    break;
                }
            }
        }
    }

    // 处理读取到的数据
    Handler mHandler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    // 显示读取到的数据
                    String readData = (String) msg.obj;
                    Log.d("BluetoothActivity", "读取到的数据：" + readData);
                    break;
            }
            return false;
        }
    });
}

在上面的代码中，我们使用 BluetoothAdapter 类来获取蓝牙适配器，使用 BluetoothDevice 类来获取蓝牙设备，使用 BluetoothSocket 类来创建和连接蓝牙套接字，使用 InputStream 和 OutputStream 类来读取和发送数据。同时，我们还创建了一个 ReadThread 线程来持续读取蓝牙设备发送过来的数据，并使用 Handler 回调来处理读取到的数据。

android java蓝牙测试代码

以下是一个简单的 Android Java 蓝牙测试代码，可以用于搜索和连接蓝牙设备：

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Set;
import java.util.UUID;

public class MainActivity extends AppCompatActivity {

    private BluetoothAdapter bluetoothAdapter;
    private ListView listView;
    private ArrayAdapter<String> adapter;
    private ArrayList<BluetoothDevice> devices;
    private ConnectThread connectThread;
    private ConnectedThread connectedThread;
    private Handler handler;

    private static final int MESSAGE_READ = 1;

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

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 初始化蓝牙适配器
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        // 初始化ListView和Adapter
        listView = (ListView) findViewById(R.id.listView);
        adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, 0);
        listView.setAdapter(adapter);

        // 初始化设备列表
        devices = new ArrayList<BluetoothDevice>();

        // 初始化Handler
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MESSAGE_READ:
                        byte[] readBuf = (byte[]) msg.obj;
                        String readMessage = new String(readBuf, 0, msg.arg1);
                        // 处理接收到的数据
                        break;
                }
            }
        };

        // 检查蓝牙是否可用
        if (bluetoothAdapter == null) {
            Toast.makeText(this, "蓝牙不可用", Toast.LENGTH_SHORT).show();
        } else {
            // 检查蓝牙是否已经开启
            if (!bluetoothAdapter.isEnabled()) {
                // 请求开启蓝牙
                BluetoothAdapter.enable();
            }
            // 显示已配对设备
            Set<BluetoothDevice> pairedDevices = bluetoothAdapter.getBondedDevices();
            if (pairedDevices.size() > 0) {
                for (BluetoothDevice device : pairedDevices) {
                    devices.add(device);
                    adapter.add(device.getName() + "\n" + device.getAddress());
                }
            }
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 关闭连接线程和数据传输线程
        if (connectThread != null) {
            connectThread.cancel();
            connectThread = null;
        }
        if (connectedThread != null) {
            connectedThread.cancel();
            connectedThread = null;
        }
    }

    // 搜索蓝牙设备
    private void searchDevices() {
        // 开始搜索
        bluetoothAdapter.startDiscovery();
    }

    // 停止搜索蓝牙设备
    private void stopSearch() {
        // 停止搜索
        bluetoothAdapter.cancelDiscovery();
    }

    // 连接蓝牙设备
    private void connectDevice(BluetoothDevice device) {
        // 开始连接
        connectThread = new ConnectThread(device);
        connectThread.start();
    }

    // 发送数据
    private void sendData(byte[] data) {
        // 发送数据
        connectedThread.write(data);
    }

    // 连接线程
    private class ConnectThread extends Thread {
        private BluetoothSocket socket;
        private BluetoothDevice device;

        public ConnectThread(BluetoothDevice device) {
            this.device = device;
            try {
                // 创建一个Socket连接
                socket = device.createRfcommSocketToServiceRecord(MY_UUID);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            // 连接
            try {
                socket.connect();
            } catch (IOException e) {
                e.printStackTrace();
                try {
                    // 关闭Socket
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                return;
            }
            // 连接成功，启动数据传输线程
            connectedThread = new ConnectedThread(socket);
            connectedThread.start();
        }

        public void cancel() {
            try {
                // 关闭Socket
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 数据传输线程
    private class ConnectedThread extends Thread {
        private BluetoothSocket socket;
        private byte[] buffer;
        private int bytes;

        public ConnectedThread(BluetoothSocket socket) {
            this.socket = socket;
            buffer = new byte[1024];
        }

        @Override
        public void run() {
            // 循环接收数据
            while (true) {
                try {
                    bytes = socket.getInputStream().read(buffer);
                    handler.obtainMessage(MESSAGE_READ, bytes, -1, buffer).sendToTarget();
                } catch (IOException e) {
                    e.printStackTrace();
                    break;
                }
            }
        }

        public void write(byte[] data) {
            try {
                // 发送数据
                socket.getOutputStream().write(data);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        public void cancel() {
            try {
                // 关闭Socket
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

注意：需要在 AndroidManifest.xml 文件中添加以下权限：

<uses-permission android:name="android.permission.BLUETOOTH"/>
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>