Android 蓝牙监听，BLE蓝牙和经典蓝牙合成的蓝牙监听案例

其他 2020-07-28 12:15:03 阅读次数: 0

1、Android 蓝牙有两个两种，一种是BLE蓝牙，另外一种是经典蓝牙。

BLE蓝牙连接与通讯使用的是 BluetoothKit 框架，BluetoothKit 框架源码地址与说明：

https://gitee.com/www163/Android-BluetoothKit

BluetoothKit 的弊端是经典蓝牙连接失败。

所以经典蓝牙，自己写了连接和通讯方式。

对于通讯来讲，分为服务端BtServer与客户端BtClient，一般是安装app方为服务端，主要是本身的蓝牙mac是固定，所以作为服务器端，被连接方为客户端。

对BLE的连接与通讯，大家可以看 BluetoothKit 框架详细说明，这里就不累赘。

下面主要是介绍经典蓝牙的连接和通讯。

ps：在蓝牙连接通讯时，前提先要配对才能正常通讯。

最下面有项目源码下载。

在经典蓝牙连接时，经常出现“run: read failed, socket might closed or timeout, read ret: -1”

主要原因是UUID的错误。

非手机终端的UUID：00001101-0000-1000-8000-00805f9B34FB

手机终端的UUID：00001105-0000-1000-8000-00805f9b34fb

1、AndroidManifest.xml 清单设置蓝牙权限

 <uses-feature
        android:name="android.hardware.bluetooth_le"
        android:required="true" />

    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

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

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

2、蓝牙通讯BtBase 基类：

package com.inuker.bluetooth;

import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Environment;
import android.util.Log;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.UUID;

public class BtBase {

    //00001101-0000-1000-8000-00805F9B34FB  -  00001101-0000-1000-8000-00805f9b34fb
    //00001106-0000-1000-8000-00805F9B34FB  -  00001105-0000-1000-8000-00805f9b34fb
    //00001105-0000-1000-8000-00805f9B34FB  -  00001105-0000-1000-8000-00805f9b34fb
    //非手机终端的UUID
    public static final UUID SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805f9B34FB");
    //手机终端的UUID
    public static final UUID MOB_UUID = UUID.fromString("00001105-0000-1000-8000-00805f9B34FB");
    private static final String FILE_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + "/bluetooth/";
    private static final int FLAG_MSG = 0;  //消息标记
    private static final int FLAG_FILE = 1; //文件标记

    private BluetoothSocket mSocket;
    private DataOutputStream mOut;
    private Listener mListener;
    public boolean isRead;
    public boolean isSending;

    BtBase(Listener listener) {
        mListener = listener;
    }

    /**
     * 循环读取对方数据(若没有数据，则阻塞等待)
     */
    void loopRead(BluetoothSocket socket) {
        mSocket = socket;
        try {
            Log.i("test","---------loopRead111--------");
            if (!mSocket.isConnected())
                mSocket.connect();
            Log.i("test","---------loopRead2222--------");
            notifyUI(Listener.CONNECTED, mSocket.getRemoteDevice());
            mOut = new DataOutputStream(mSocket.getOutputStream());
            DataInputStream in = new DataInputStream(mSocket.getInputStream());
            isRead = true;
            while (isRead) { //死循环读取
                Log.i("Test","------------------server in.readInt="+in.readInt());
                switch (in.readInt()) {
                    case FLAG_MSG: //读取短消息
                        String msg = in.readUTF();
                        notifyUI(Listener.MSG, "接收短消息：" + msg);
                        break;
                    case FLAG_FILE: //读取文件
                        Util.mkdirs(FILE_PATH);
                        String fileName = in.readUTF(); //文件名
                        long fileLen = in.readLong(); //文件长度
                        // 读取文件内容
                        long len = 0;
                        int r;
                        byte[] b = new byte[4 * 1024];
                        FileOutputStream out = new FileOutputStream(FILE_PATH + fileName);
                        notifyUI(Listener.MSG, "正在接收文件(" + fileName + "),请稍后...");
                        while ((r = in.read(b)) != -1) {
                            out.write(b, 0, r);
                            len += r;
                            if (len >= fileLen)
                                break;
                        }
                        notifyUI(Listener.MSG, "文件接收完成(存放在:" + FILE_PATH + ")");
                        break;
                }
            }
        } catch (Throwable e) {
            e.printStackTrace();
            Log.i("Test","-------------BtBase close-----------------");
            close();
        }
    }

    void loopRead2(BluetoothSocket socket) {
        mSocket = socket;
        try {
            Log.i("test","---------loopRead111--------");
            if (!mSocket.isConnected())
                mSocket.connect();
            Log.i("test","---------loopRead2222--------");
            notifyUI(Listener.CONNECTED, mSocket.getRemoteDevice());


        } catch (Throwable e) {
            e.printStackTrace();
            Log.i("Test","-------------BtBase close-----------------");
            close();
        }
    }

    /**
     * 循环读取对方数据(若没有数据，则阻塞等待)
     */
    void loopReadMsg() {

        try {

//            notifyUI(Listener.CONNECTED, mSocket.getRemoteDevice());
            Log.i("Test","-----------BtBase-loopReadMsg2---------");
//            mOut = new DataOutputStream(mSocket.getOutputStream());
            DataInputStream in = new DataInputStream(mSocket.getInputStream());
            isRead = true;
            Log.i("Test","-----------BtBase-loopReadMsg3---------");
            while (isRead) { //死循环读取
                String msg = in.readUTF();
                Log.i("Test","-----------BtBase-loopReadMsg4---------");
                notifyUI(Listener.MSG, "接收短消息：" + msg);

            }
        } catch (Throwable e) {
            e.printStackTrace();
            close();
        }
    }


    /**
     * 发送短消息
     */
    public void sendMsg2(String msg) {
        Log.i("Test","-----------sendMsg3----2-----");
        if (checkSend()) return;
        isSending = true;
        Log.i("Test","-----------sendMsg3----3-----");
        try {
            Log.i("Test","----------sendMsg2--mSocket="+mSocket);
            OutputStream out = mSocket.getOutputStream();
            Log.i("Test","----------sendMsg2--out="+out);
            mOut = new DataOutputStream(out);
            mOut.writeInt(FLAG_MSG); //消息标记
            mOut.writeUTF(msg);
            mOut.flush();
            notifyUI(Listener.MSG, "发送短消息：" + msg);
        } catch (Throwable e) {
            e.printStackTrace();
//            close();
        }
        isSending = false;
    }

    /**
     * 发送短消息
     */
    public void sendMsg(String msg) {
        Log.i("Test","-----------sendMsg3----2-----");
        if (checkSend()) return;
        isSending = true;
        Log.i("Test","-----------sendMsg3----3-----");
        try {

            mOut = new DataOutputStream(mSocket.getOutputStream());
            mOut.writeInt(FLAG_MSG); //消息标记
            mOut.writeUTF(msg);
            mOut.flush();
            notifyUI(Listener.MSG, "发送短消息：" + msg);
        } catch (Throwable e) {
            e.printStackTrace();
//            close();
        }
        isSending = false;
    }


    /**
     * 发送文件
     */
    public void sendFile(final String filePath) {
        if (checkSend()) return;
        isSending = true;
        Util.EXECUTOR.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    FileInputStream in = new FileInputStream(filePath);
                    File file = new File(filePath);
                    mOut.writeInt(FLAG_FILE); //文件标记
                    mOut.writeUTF(file.getName()); //文件名
                    mOut.writeLong(file.length()); //文件长度
                    int r;
                    byte[] b = new byte[4 * 1024];
                    notifyUI(Listener.MSG, "正在发送文件(" + filePath + "),请稍后...");
                    while ((r = in.read(b)) != -1)
                        mOut.write(b, 0, r);
                    mOut.flush();
                    notifyUI(Listener.MSG, "文件发送完成.");
                } catch (Throwable e) {
                    close();
                }
                isSending = false;
            }
        });
    }

    /**
     * 释放监听引用(例如释放对Activity引用，避免内存泄漏)
     */
    public void unListener() {
        mListener = null;
    }

    /**
     * 关闭Socket连接
     */
    public void close() {
        try {
            Log.i("Test","---------关闭Socket连接-----------");
            isRead = false;
            if(mSocket!=null){
                mSocket.close();
                notifyUI(Listener.DISCONNECTED, null);
            }
//            notifyUI(Listener.DISCONNECTED, null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

    /**
     * 当前设备与指定设备是否连接
     */
    public boolean isConnected(BluetoothDevice dev) {
        boolean connected = (mSocket != null && mSocket.isConnected());
        if (dev == null)
            return connected;
        return connected && mSocket.getRemoteDevice().equals(dev);
    }

    // ============================================通知UI===========================================================
    public boolean checkSend() {
        if (isSending) {
            MyApplication.toast("正在发送其它数据,请稍后再发...", 0);
            return true;
        }
        return false;
    }

    public void notifyUI(final int state, final Object obj) {
        MyApplication.runUi(new Runnable() {
            @Override
            public void run() {
                try {
                    if (mListener != null)
                        mListener.socketNotify(state, obj);
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public interface Listener {
        int DISCONNECTED = 0;
        int CONNECTED = 1;
        int MSG = 2;

        void socketNotify(int state, Object obj);
    }

}

3、服务器端BtServer 代码：

package com.inuker.bluetooth;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.util.Log;

import java.lang.reflect.Method;
import java.util.UUID;

public class BtServer extends BtBase{

    private static final String TAG = BtServer.class.getSimpleName();
    private BluetoothServerSocket mSSocket;
    private BluetoothSocket socket;

    BtServer(Listener listener) {
        super(listener);
//        listen();
    }

    /**
     * 监听客户端发起的连接
     */
    public void listen() {
        try {
//            Method listenMethod = btClass.getMethod("listenUsingRfcommOn", new Class[]{int.class});

            BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
//            mSSocket = adapter.listenUsingRfcommWithServiceRecord(TAG, SPP_UUID); //加密传输，Android强制执行配对，弹窗显示配对码
            mSSocket = adapter.listenUsingInsecureRfcommWithServiceRecord(TAG, MOB_UUID); //明文传输(不安全)，无需配对
            // 开启子线程
            Util.EXECUTOR.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                         socket = mSSocket.accept(); // 监听连接
//                        mSSocket.close(); // 关闭监听，只连接一个设备
                        loopRead(socket); // 循环读取
                    } catch (Throwable e) {
                        close();
                    }
                }
            });
        } catch (Throwable e) {
            close();
        }
    }

    public void listen(UUID uuid) {
        try {
//            Method listenMethod = btClass.getMethod("listenUsingRfcommOn", new Class[]{int.class});
            Log.i("Test","--------------------uuid="+uuid);
            BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
//            mSSocket = adapter.listenUsingRfcommWithServiceRecord(TAG, SPP_UUID); //加密传输，Android强制执行配对，弹窗显示配对码
            mSSocket = adapter.listenUsingInsecureRfcommWithServiceRecord(TAG, uuid); //明文传输(不安全)，无需配对
            // 开启子线程
            Util.EXECUTOR.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                         socket = mSSocket.accept(); // 监听连接
//                        mSSocket.close(); // 关闭监听，只连接一个设备
                        loopRead(socket); // 循环读取
                    } catch (Throwable e) {
                        close();
                    }
                }
            });
        } catch (Throwable e) {
            close();
        }
    }

    @Override
    public void close() {
        super.close();
        try {
            if(socket!=null){
                socket.close();
            }

            if(mSSocket!=null){
                mSSocket.close();
            }

        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

}

4、客户端BtClient 代码：

package com.inuker.bluetooth;

import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.ParcelUuid;
import android.util.Log;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.UUID;

public class BtClient extends BtBase {

    private  BluetoothSocket mSocket;
    boolean flag = false;

    BtClient(Listener listener) {
        super(listener);
    }

    /**
     * 与远端设备建立长连接
     *
     * @param dev 远端设备
     */
    public void connect(BluetoothDevice dev) {
        close();
        try {

//             final BluetoothSocket socket = dev.createRfcommSocketToServiceRecord(SPP_UUID); //加密传输，Android系统强制配对，弹窗显示配对码
            final BluetoothSocket socket = dev.createInsecureRfcommSocketToServiceRecord(SPP_UUID); //明文传输(不安全)，无需配对
            Log.i("Test","------------------socket="+socket);
            // 开启子线程
            Util.EXECUTOR.execute(new Runnable() {
                @Override
                public void run() {
                    Log.i("Test","-----------connect-------");
                    loopRead(socket); //循环读取

                }
            });
        } catch (Throwable e) {
            Log.i("Test","-------------BtClient close-----------------");
            close();
        }
    }


    public void connect2(BluetoothDevice dev,UUID uuid) {
        close();
        try {

//            ParcelUuid[] parcel = dev.getUuids();
//            UUID uuid = parcel[0].getUuid();
//             final BluetoothSocket socket = dev.createRfcommSocketToServiceRecord(SPP_UUID); //加密传输，Android系统强制配对，弹窗显示配对码
            final BluetoothSocket socket = dev.createInsecureRfcommSocketToServiceRecord(uuid); //明文传输(不安全)，无需配对
            Log.i("Test","------------------socket="+socket);
            // 开启子线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        boolean isCon = socket.isConnected();
                        Log.i("Test","------------------isCon="+isCon);
                        socket.connect();
                        loopRead2(socket); //循环读取


                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }
            }).start();

        } catch (Throwable e) {
            Log.i("Test","-------------BtClient close-----------------");
            close();
        }
    }



    public void connect3(BluetoothDevice dev) {
        close();
        try {

//            ParcelUuid[] parcel = dev.getUuids();
//            UUID uuid = parcel[0].getUuid();
//             final BluetoothSocket socket = dev.createRfcommSocketToServiceRecord(SPP_UUID); //加密传输，Android系统强制配对，弹窗显示配对码
            final BluetoothSocket socket = dev.createInsecureRfcommSocketToServiceRecord(SPP_UUID); //明文传输(不安全)，无需配对
            Log.i("Test","------------------socket="+socket);
            // 开启子线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        boolean isCon = socket.isConnected();
                        Log.i("Test","------------------isCon="+isCon);
                        socket.connect();
                        loopRead2(socket); //循环读取


                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }
            }).start();

        } catch (Throwable e) {
            Log.i("Test","-------------BtClient close-----------------");
            close();
        }
    }



    public void loopReadMsg(BluetoothDevice dev) {
//        close();
        try {
            Log.i("Test","-----------loopReadMsg1---------");
//             final BluetoothSocket socket = dev.createRfcommSocketToServiceRecord(SPP_UUID); //加密传输，Android系统强制配对，弹窗显示配对码
//            final BluetoothSocket socket = dev.createInsecureRfcommSocketToServiceRecord(SPP_UUID); //明文传输(不安全)，无需配对
            // 开启子线程
            Util.EXECUTOR.execute(new Runnable() {
                @Override
                public void run() {
                    Log.i("Test","-----------loopReadMsg2---------");
                    loopReadMsg(); //循环读取
                }
            });
        } catch (Throwable e) {
            e.printStackTrace();
            Log.i("Test","-----------loopReadMsg3---------ex="+e.getMessage());
            close();
        }
    }


    public void clientSendMsg(String msg) {
        Log.i("Test","-----------sendMsg3----2-----");
        if (checkSend()) return;
        isSending = true;
        Log.i("Test","-----------sendMsg3----3-----");
        try {

            Log.i("Test","----------sendMsg2--mSocket="+mSocket);
            OutputStream out = mSocket.getOutputStream();
            Log.i("Test","----------sendMsg2--out="+out);
            DataOutputStream mOut = new DataOutputStream(out);
            mOut.writeInt(Listener.MSG); //消息标记
            mOut.writeUTF(msg);
            mOut.flush();
            notifyUI(Listener.MSG, "发送短消息：" + msg);
        } catch (Throwable e) {
            e.printStackTrace();
//            close();
        }
        isSending = false;
    }




}

5、Activity 中调用案例：

package com.inuker.bluetooth;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelUuid;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

import com.inuker.bluetooth.library.connect.listener.BluetoothStateListener;
import com.inuker.bluetooth.library.search.SearchResult;
import com.inuker.bluetooth.library.utils.BluetoothLog;
import com.inuker.bluetooth.view.PullRefreshListView;
import com.inuker.bluetooth.view.PullToRefreshFrameLayout;

import java.io.File;
import java.util.ArrayList;
import java.util.UUID;


public class CommonFragment extends Fragment implements BtBase.Listener, BtReceiver.Listener, BtDevAdapter.Listener{

    private TextView mTips;
    private EditText mInputMsg;
    private EditText mInputFile;
    private TextView mLogs;
    private BtReceiver mBtReceiver;
    private  BtDevAdapter mBtDevAdapter;
    private  BtClient mClient;

    private View view;
    private Context context;

    private Button scanBtn,sendMsgBtn,sendFileBtn,listenTerBtn,listenMobBtn;
    private BluetoothDevice remoteDev;
    private boolean isLoop = true;
    private BtServer mServer;
    BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

    private boolean isListen = false;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_common, container, false);
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        view = getView();
        context = view.getContext();
        mBtDevAdapter = new BtDevAdapter(this);
        mClient = new BtClient(this);
        mServer = new BtServer(this);

        listenTerBtn = view.findViewById(R.id.listen_ter);
        listenMobBtn = view.findViewById(R.id.listen_mob);


        RecyclerView rv = view.findViewById(R.id.rv_bt);
        rv.setLayoutManager(new LinearLayoutManager(context));
        rv.setAdapter(mBtDevAdapter);
        mTips = view.findViewById(R.id.tv_tips);
        mInputMsg = view.findViewById(R.id.input_msg);
        mInputFile = view.findViewById(R.id.input_file);
        mLogs = view.findViewById(R.id.tv_log);

        scanBtn = view.findViewById(R.id.button2);
        sendMsgBtn = view.findViewById(R.id.btn_sendMsg);
        sendFileBtn = view.findViewById(R.id.btn_sendFile);
        mBtReceiver = new BtReceiver(context, this);//注册蓝牙广播
        BluetoothAdapter.getDefaultAdapter().startDiscovery();


        scanBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                reScan();
            }
        });

        sendMsgBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                String txt = sendMsgBtn.getText().toString();
                Log.i("Test","-----is="+"发送信息".equals(txt));
                if("发送信息".equals(txt)){
//                    handler3.sendEmptyMessage(0);
                    mLogs.setText("");
                        sendMsgBtn.setText("关闭");
//                        sendMsg11();
//                        isLoop = true;
//
                    loopSendMsg();


                }else{
//                        isLoop = false;
//                        sendMsgBtn.setText("发送信息");
                    handler3.sendEmptyMessage(1);
                }

            }
        });

        sendFileBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                sendFile();
            }
        });

        listenTerBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mServer.close();
                mServer.listen(BtBase.SPP_UUID);
                isListen = true;
            }
        });

        listenMobBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mServer.close();
                mServer.listen(BtBase.MOB_UUID);
                isListen = true;
            }
        });


    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        context.unregisterReceiver(mBtReceiver);
        mClient.unListener();
        mClient.close();

        mServer.unListener();
        mServer.close();
    }


    @Override
    public void socketNotify(int state, Object obj) {
//        if (isDestroyed())
//            return;
        String msg = null;
        switch (state) {
            case BtBase.Listener.CONNECTED:
                BluetoothDevice dev = (BluetoothDevice) obj;
                msg = String.format("与%s(%s)连接成功", dev.getName(), dev.getAddress());
                remoteDev = dev;
                mTips.setText(msg);
                break;
            case BtBase.Listener.DISCONNECTED:
                msg = "连接断开";
                mTips.setText(msg);
                break;
            case BtBase.Listener.MSG:
                msg = String.format("\n%s", obj);
                mLogs.append(msg);

                break;
        }
        MyApplication.toast(msg, 0);
    }

    @Override
    public void onItemClick(BluetoothDevice dev) {

        mServer.close();
        mBluetoothAdapter.cancelDiscovery();

        Log.i("Test","------name="+dev.getName()+","+dev.getAddress());
        if (mClient.isConnected(dev)) {
            remoteDev = dev;
            MyApplication.toast("已经连接了", 0);
            return;
        }

        int state = dev.getBondState();
        if(state != BluetoothDevice.BOND_BONDED){
            boolean isPair = BluetoothUtils.pair(dev.getAddress(),"");
//
            Log.i("Test","-------------------isPair="+isPair);
            MyApplication.toast("请先配对蓝牙", 0);
            reScan();
            return;
        }

        ParcelUuid[] parcel = dev.getUuids();

        boolean isContain = isContainUUID(dev);
        if(isContain){
            mServer.listen(BtBase.SPP_UUID);
            mClient.connect2(dev,BtBase.SPP_UUID);
        }else{
            mServer.listen(BtBase.MOB_UUID);
            mClient.connect2(dev,BtBase.MOB_UUID);

        }

        MyApplication.toast("正在连接...", 0);
        mTips.setText("正在连接...");
    }

    @Override
    public void foundDev(BluetoothDevice dev) {
        mBtDevAdapter.add(dev);
    }


    // 重新扫描
    public void reScan() {
        mBtDevAdapter.reScan();
    }

    //发送信息
    public void sendMsg2() {
        if (mClient.isConnected(null)) {
            String msg = mInputMsg.getText().toString();
            if (TextUtils.isEmpty(msg))
                MyApplication.toast("消息不能空", 0);
            else
                mClient.sendMsg(msg);
        } else
            MyApplication.toast("没有连接", 0);
    }

    public void sendMsgByClient() {

            mClient.sendMsg("发送成功");

    }


    //发送信息
    public void loopReadMsg() {
        if (mClient.isConnected(null)) {
            String msg = "发送成功......";
            mClient.loopReadMsg();

        } else
            MyApplication.toast("没有连接", 0);
    }


    public void sendMsg() {
        Log.i("Test","-----------sendMsg1---------");
        if(remoteDev == null){
            MyApplication.toast("请选连接蓝牙", 0);
            return;
        }
        Log.i("Test","-----------sendMsg2---------");
        if (!mClient.isConnected(remoteDev)) {
            MyApplication.toast("请选连接蓝牙", 0);
            return;
        }
        Log.i("Test","-----------sendMsg3---------");
        mClient.loopReadMsg(remoteDev);
    }


    //发送文件
    public void sendFile() {
        if (mClient.isConnected(null)) {
            String filePath = mInputFile.getText().toString();
            if (TextUtils.isEmpty(filePath) || !new File(filePath).isFile())
                MyApplication.toast("文件无效", 0);
            else
                mClient.sendFile(filePath);
        } else
            MyApplication.toast("没有连接", 0);
    }

    private void loopRead(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (isLoop){
//                    sendMsg3();
                    loopReadMsg();
                }
            }
        }).start();
    }

    private Handler handler = new Handler(){

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            String txt = sendMsgBtn.getText().toString();
            if("发送信息".equals(txt)){
//                    loopRead();
//                loopRead();
                if (mClient.isConnected(null)) {
//                    String msg = "发送成功......";
                    sendMsgBtn.setText("关闭");
                    mClient.loopReadMsg();

                    isLoop = true;

                } else
                    MyApplication.toast("没有连接", 0);

            }else{
                isLoop = false;
                sendMsgBtn.setText("发送信息");
            }

        }
    };


    public void serverSendMsg() {
        if (mServer.isConnected(null)) {
//            String msg = mInputMsg.getText().toString();
//            if (TextUtils.isEmpty(msg))
//                MyApplication.toast("消息不能空", 0);
//            else
                mServer.sendMsg("测试。。。。");
        } else
            MyApplication.toast("没有连接", 0);
    }

    private boolean isContainUUID(BluetoothDevice dev){
        ParcelUuid[] pars = dev.getUuids();
        for(ParcelUuid p : pars){
            UUID u = p.getUuid();
            if(BtBase.SPP_UUID.equals(u)){
                return true;
            }
        }
        return false;
    }


    private Handler handler3 = new Handler(){

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
                case 0:
//                    sendMsgBtn.setText("关闭");
                    sendMsgByClient();
                    isLoop = true;
                    break;
                case 1:
                    isLoop = false;
                    sendMsgBtn.setText("发送信息");
                    break;
            }

        }
    };


    private void loopSendMsg(){
        new Thread(new Runnable() {
            @Override
            public void run() {

                while(isLoop){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    handler3.sendEmptyMessage(0);

                }
            }
        }).start();
    }
}

6、效果如下：

 

 XT300 是打印机终端：

 K5为手机蓝牙连接如下：

7、项目源码：

https://github.com/hongchuanfeng/Android-Bluetooth-Demo

猜你喜欢

转载自www.cnblogs.com/zoro-zero/p/13390268.html
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022