如何从android蓝牙建立与obd2的连接

Question

我需要通过我的安卓应用程序与 obd2 设备建立连接，比如扭矩应用程序。我需要从安卓手机配对它。

Answer 1

此服务用于查找配对的 OBD-2，连接并持续获取实时数据，即标准 PID，并在后台查找基于标准 PID 的其他实时参数，如总行驶距离、油耗等。这在移动和主机（安装在汽车中）中进行了测试。参考 android-obd-reader 示例应用：

https://github.com/md-sohrab-alam/android-obd-reader

package com.sohrab.obd.reader.service;

import android.app.IntentService;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.text.TextUtils;
import android.widget.Toast;

import com.sohrab.obd.reader.application.ObdPreferences;
import com.sohrab.obd.reader.constants.DefineObdReader;
import com.sohrab.obd.reader.enums.ObdProtocols;
import com.sohrab.obd.reader.obdCommand.ObdCommand;
import com.sohrab.obd.reader.obdCommand.ObdConfiguration;
import com.sohrab.obd.reader.obdCommand.control.TroubleCodesCommand;
import com.sohrab.obd.reader.obdCommand.protocol.EchoOffCommand;
import com.sohrab.obd.reader.obdCommand.protocol.LineFeedOffCommand;
import com.sohrab.obd.reader.obdCommand.protocol.ObdResetCommand;
import com.sohrab.obd.reader.obdCommand.protocol.SelectProtocolCommand;
import com.sohrab.obd.reader.obdCommand.protocol.SpacesOffCommand;
import com.sohrab.obd.reader.obdCommand.protocol.TimeoutCommand;
import com.sohrab.obd.reader.trip.TripRecord;
import com.sohrab.obd.reader.utils.L;

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

import app.com.android_obd_reader.R;


/**
 * created by sohrab 01/12/2017
 * <p>
 * Service for managing connection and data communication with a OBD-2 in background and update data to RealTime screen.
 * It connects paired OBD-2 Or wait until paired.
 * Once it is paired, try to connect with Bluetooth Socket along with some specific OBD-2 command,
 * if connected, fetch data until OBD-2 disconnected and if somehow,
 * it disconnected then go to connect and this is in loop until user quit from App.
 */

public class ObdReaderService extends IntentService implements DefineObdReader {
    private static final String TAG = "ObdReaderService";
    // receive when OBD-2 connected


    public final static char PID_STATUS_SUCCESS = '1';
    public final static int DEVICE_NOT_PAIRED = 1;
    public final static int OBD_NOT_RESPONDING = 2;
    public final static int OBD_CONNECTED = 3;
    public final static int INIT_OBD = 4;


    //   private static final int NOTIFICATION_ID = 101;
    private static final int DELAY_FIFTEEN_SECOND = 15000;
    private static final int DELAY_TWO_SECOND = 2000;
    // this is used to find TroubleCode if true. This is used in InspectionActivity where fault is shown.
    public boolean mIsFaultCodeRead = true;
    private final IBinder mBinder = new LocalBinder();
    //   private int mLastNotificationType;
    // name of OBD
    private String OBD_SMALL = "obd";
    private String OBD_CAPS = "OBD";
    private String V_LINK = "V-LINK";
    private BluetoothManager mBluetoothManager;//Bluetooth Manager
    private BluetoothAdapter mBluetoothAdapter;//Bluetooth adapter
    private BluetoothSocket mSocket;
    //set OBD-2 connection status
    private boolean isConnected;
    // private NotificationCompat.Builder mNotificationBuilder;
    //  private NotificationManager mNotificationManager;
    private boolean mIsRunningSuccess;
    private Intent mIntent = new Intent(ACTION_READ_OBD_REAL_TIME_DATA);
    private char[] mSupportedPids;

    public ObdReaderService() {
        super("ObdReaderService");
        L.i("ObdReaderService");
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        L.i("onHandleIntent" + "Thread is :: " + Thread.currentThread().getId());

        // setUpAsForeground();
        if (initiateConnection()) {

            if (!isEnable()) {
                enableBlutooth();
            }

            findObdDevicesAndConnect();
        }

        L.i("onHandleIntent bottom");
        //  mNotificationManager.cancel(NOTIFICATION_ID);
        ObdPreferences.get(getApplicationContext()).setServiceRunningStatus(false);
        ObdPreferences.get(getApplicationContext()).setIsOBDconnected(false);
        TripRecord.getTripRecode(this).clear();
    }

    /**
     * This method is recursively called until service stopped.
     */
    private void findObdDevicesAndConnect() {

        if (!isConnected) {
            findPairedDevices();
        }

        if (isConnected) {
            executeCommand();
        }

        if (ObdPreferences.get(getApplicationContext()).getServiceRunningStatus()) {
            L.i("findObdDevicesAndConnect()");
            findObdDevicesAndConnect();
        }

    }

    /**
     * find paired OBD-2 devices in loop until found and connected or service stopped.
     */
    private void findPairedDevices() {

        while (!isConnected && ObdPreferences.get(getApplicationContext()).getServiceRunningStatus()) {
            if (mBluetoothAdapter != null) {
                boolean deviceFound = false;

                Set<BluetoothDevice> bluetoothDevices = mBluetoothAdapter.getBondedDevices();
                for (BluetoothDevice device : bluetoothDevices) {
                    if (device != null) {
                        String name = device.getName();
                        if (name != null && (name.contains(OBD_SMALL) || name.contains(OBD_CAPS) || name.toUpperCase().contains(V_LINK))) {
                            try {
                                connectOBDDevice(device);
                            } catch (Exception e) {
                                L.i("connectOBDDevice return Exception :: " + e != null ? e.getMessage() : "");
                            }
                            deviceFound = true;
                            break;
                        }
                    }

                }

                if (!deviceFound) {
                  /*  if (mLastNotificationType != DEVICE_NOT_PAIRED) {
                        mLastNotificationType = DEVICE_NOT_PAIRED;
                        updateNotification(getString(R.string.waiting_for_obd));
                    }*/
                    sendBroadcast(ACTION_OBD_CONNECTION_STATUS, getString(R.string.waiting_for_obd));
                }
            }
        }
    }

    /**
     * connects specified bluetooth OBD device with Bluetooth Socket.
     * if bluetooth socked connected then use some init OBD-2 command to initialize,
     * if command response is success, then we assume connection is established and ready to fetch data.
     *
     * @param device
     * @throws Exception
     */
    public void connectOBDDevice(final BluetoothDevice device) throws Exception {

        try {
            mSocket = (BluetoothSocket) device.getClass().getMethod("createInsecureRfcommSocket", new Class[]{int.class}).invoke(device, 1);
        } catch (Exception e) {
            // e.printStackTrace();
            L.i("createInsecureRfcommSocket failed");
            closeSocket();
        }

        if (mSocket != null) {
            try {
                mBluetoothAdapter.cancelDiscovery();
                Thread.sleep(500);
                mSocket.connect();
                L.i("Socket connected");
            } catch (Exception e) {
                L.i("Socket connection  exception :: " + e.getMessage());
                //   e.printStackTrace();
                closeSocket();
            }

            boolean isSockedConnected = mSocket.isConnected();
            if (isSockedConnected) {
                try {
                    Thread.sleep(DELAY_TWO_SECOND);
                  /*  if (mLastNotificationType != INIT_OBD) {
                        mLastNotificationType = INIT_OBD;
                        updateNotification(getString(R.string.connecting_to_ecu));
                    }*/
                    L.i("Executing reset command in new Thread :: " + Thread.currentThread().getId());
                    final Thread newThread = new Thread(new Runnable() {
                        @Override
                        public void run() {
                            try {

                                // this thread is required because in Headunit command.run method block infinitly ,
                                // therefore this thread life is maximum 15 second so that block can be handled.
                                mIsRunningSuccess = false;
                                new ObdResetCommand().run(mSocket.getInputStream(), mSocket.getOutputStream());
                                Thread.sleep(1000);
                                new EchoOffCommand().run(mSocket.getInputStream(), mSocket.getOutputStream());
                                Thread.sleep(200);
                                new LineFeedOffCommand().run(mSocket.getInputStream(), mSocket.getOutputStream());
                                Thread.sleep(200);
                                new SpacesOffCommand().run(mSocket.getInputStream(), mSocket.getOutputStream());
                                Thread.sleep(200);
                                new SpacesOffCommand().run(mSocket.getInputStream(), mSocket.getOutputStream());
                                Thread.sleep(200);
                                new TimeoutCommand(125).run(mSocket.getInputStream(), mSocket.getOutputStream());
                                //  updateNotification(getString(R.string.searching_protocol));
                                Thread.sleep(200);
                                new SelectProtocolCommand(ObdProtocols.AUTO).run(mSocket.getInputStream(), mSocket.getOutputStream());
                                Thread.sleep(200);
                                new EchoOffCommand().run(mSocket.getInputStream(), mSocket.getOutputStream());
                                //  updateNotification(getString(R.string.searching_supported_sensor));
                                Thread.sleep(200);
                                mIsRunningSuccess = true;
                                // checkPid0To20(true);

                            } catch (Exception e) {
                                mIsRunningSuccess = false;
                                L.i("In new thread reset command  exception :: " + e != null ? e.getMessage() : "");
                            }

                        }
                    });

                    newThread.start();
                    newThread.join(DELAY_FIFTEEN_SECOND);
                    L.i("Thread wake to check reset command status  i.e  :: " + Thread.currentThread().getId() + ",  mIsRunningSuccess :: " + mIsRunningSuccess);
                    isSockedConnected = mIsRunningSuccess;

                } catch (Exception e) {
                    L.i(" reset command Exception  :: " + e.getMessage());
                    isSockedConnected = false;
                }

            }

            if (mSocket != null && mSocket.isConnected() && isSockedConnected) {
                setConnection(false);
               /* if (mLastNotificationType != OBD_CONNECTED) {
                    mLastNotificationType = OBD_CONNECTED;
                    updateNotification(getString(R.string.connected_ok));
                }
*/
            } else {
                if (mSupportedPids != null && mSupportedPids.length == 32) {

                    if ((mSupportedPids[12] != PID_STATUS_SUCCESS) || (mSupportedPids[11] != PID_STATUS_SUCCESS)) {
                        // speed pid not supportedsupported
                        // updateNotification(getString(R.string.unable_to_connect));
                        sendBroadcast(ACTION_OBD_CONNECTION_STATUS, getString(R.string.unable_to_connect));
                        return;
                    }
                }

                sendBroadcast(ACTION_OBD_CONNECTION_STATUS, getString(R.string.obd2_adapter_not_responding));
/*
                if (mLastNotificationType != OBD_NOT_RESPONDING) {
                    mLastNotificationType = OBD_NOT_RESPONDING;
                    updateNotification(getString(R.string.obd2_adapter_not_responding));
                }
*/
            }
        }

    }


    /**
     * Once OBD-2 connected, this method will execute to fetch data continuously until OBD disconnected or Service stopped.
     */
    private void executeCommand() {
        L.i("executing commands thread is :: " + Thread.currentThread().getId());
        TripRecord tripRecord = TripRecord.getTripRecode(this);
        ArrayList<ObdCommand> commands = (ArrayList<ObdCommand>) ObdConfiguration.getmObdCommands().clone();
        int count = 0;
        while (mSocket != null && mSocket.isConnected() && commands.size() > count && isConnected && ObdPreferences.get(getApplicationContext()).getServiceRunningStatus()) {

            ObdCommand command = commands.get(count);
            try {

                L.i("command run :: " + command.getName());
                command.run(mSocket.getInputStream(), mSocket.getOutputStream());
                L.i("result is :: " + command.getFormattedResult() + " :: name is :: " + command.getName());
                tripRecord.updateTrip(command.getName(), command);
                if (mIsFaultCodeRead) {
                    try {
                        TroubleCodesCommand troubleCodesCommand = new TroubleCodesCommand();
                        troubleCodesCommand.run(mSocket.getInputStream(), mSocket.getOutputStream());
                        tripRecord.updateTrip(troubleCodesCommand.getName(), troubleCodesCommand);
                        mIsFaultCodeRead = false;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

                if (mIntent == null)
                    mIntent = new Intent(ACTION_READ_OBD_REAL_TIME_DATA);
                sendBroadcast(mIntent);

            } catch (Exception e) {
                L.i("execute command Exception  :: " + e.getMessage());

                if (!TextUtils.isEmpty(e.getMessage()) && (e.getMessage().equals("Broken pipe") || e.getMessage().equals("Connection reset by peer"))) {
                    L.i("command Exception  :: " + e.getMessage());
                    setDisconnection();
/*
                    if (mLastNotificationType != OBD_NOT_RESPONDING) {
                        mLastNotificationType = OBD_NOT_RESPONDING;
                        updateNotification(getString(R.string.obd2_adapter_not_responding));
                    }
*/
                }
            }
            count++;
            if (count == commands.size()) {
                count = 0;
            }

        }

        // exit loop means connection lost, so set connection status false
        isConnected = false;

    }

    /**
     * send broadcast with specific action and data
     *
     * @param action
     * @param data
     */
    private void sendBroadcast(final String action, String data) {
        final Intent intent = new Intent(action);
        intent.putExtra(ObdReaderService.INTENT_OBD_EXTRA_DATA, data);
        sendBroadcast(intent);
    }

    /**
     * send broadcast with specific action
     *
     * @param action
     */
    private void broadcastUpdate(final String action) {
        final Intent intent = new Intent(action);
        sendBroadcast(intent);
    }

    @Override
    public void onCreate() {
        super.onCreate();
        //fetchLocation();
        ObdPreferences.get(getApplicationContext()).setServiceRunningStatus(true);
        ObdPreferences.get(getApplicationContext()).setIsOBDconnected(false);
        //   mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        L.i("Service Created :: ");
    }


    /**
     * check whether this devices support bluetooth
     *
     * @return
     */
    protected boolean initiateConnection() {
        boolean isBlueToothSupported = getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH);
        boolean isInitialized = initialize();

        if (!isBlueToothSupported || !isInitialized) {
            Toast.makeText(this, getString(R.string.bluetooth_unsupported), Toast.LENGTH_SHORT).show();
            return false;
        }

        return true;
    }

    /**
     * check BluetoothServices available in this device or not
     *
     * @return
     */
    public boolean initialize() {
        if (mBluetoothManager == null) {
            mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
            if (mBluetoothManager == null) {

                return false;
            }
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
            mBluetoothAdapter = mBluetoothManager.getAdapter();
        } else {
            mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        }
        if (mBluetoothAdapter == null) {
            return false;
        }
        return true;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        L.i("service onDestroy");
        //mNotificationManager.cancel(NOTIFICATION_ID);
        closeSocket();
        ObdPreferences.get(getApplicationContext()).setServiceRunningStatus(false);
        ObdPreferences.get(getApplicationContext()).setIsOBDconnected(false);
        TripRecord.getTripRecode(this).clear();
    }

    /**
     * close Bluetooth Socket
     */
    private void closeSocket() {
        L.i("socket closed :: ");
        if (mSocket != null) {
            try {
                mSocket.close();
            } catch (IOException e) {
                L.i("socket closing failed :: ");
            }
        }
    }

    /**
     * check whether Bluetooth is enable or not
     *
     * @return
     */
    public boolean isEnable() {
        if (mBluetoothAdapter == null)
            return false;
        return mBluetoothAdapter.isEnabled();

    }

    /**
     * enable bluetooth without user interaction
     *
     * @return
     */
    public boolean enableBlutooth() {
        if (mBluetoothAdapter != null)
            return mBluetoothAdapter.enable();
        return false;
    }

    @Override
    public boolean stopService(Intent name) {
        ObdPreferences.get(getApplicationContext()).setServiceRunningStatus(false);
        return super.stopService(name);

    }

    /*Method used to set device disconnected state through the application...*/
    public void setDisconnection() {
/*
        if (mLastNotificationType != OBD_NOT_RESPONDING) {
            mLastNotificationType = OBD_NOT_RESPONDING;
            updateNotification(getString(R.string.obd2_adapter_not_responding));
        }
*/

        ObdPreferences.get(getApplicationContext()).setIsOBDconnected(false);
        isConnected = false;
        closeSocket();
        L.i("socket disconnected :: ");
      //  broadcastUpdate(ACTION_OBD_DISCONNECTED);
        sendBroadcast(ACTION_OBD_CONNECTION_STATUS, getString(R.string.connect_lost));
    }

    /*Method used to set device connected state through the application...*/
    private void setConnection(boolean isFromBle) {

        ObdPreferences.get(getApplicationContext()).setIsOBDconnected(true);
        isConnected = true;
       // sendBroadcast(ACTION_OBD_CONNECTED, String.valueOf(isFromBle));
        sendBroadcast(ACTION_OBD_CONNECTION_STATUS, getString(R.string.obd_connected));
    }

    /**
     * create Binder instance used to return in onBind method
     */
    public class LocalBinder extends Binder {
        public ObdReaderService getService() {
            return ObdReaderService.this;
        }
    }

}

Answer 2

此代码将帮助您与任何蓝牙设备配对，试一试

BluetoothDemo.java

package com.bluetooth;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Set;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothClass;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelUuid;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;
import android.widget.AdapterView.OnItemClickListener;

public class BluetoothDemo extends Activity {
    /** Called when the activity is first created. */
    ListView listViewPaired;
    ListView listViewDetected;
    ArrayList<String> arrayListpaired;
    Button buttonSearch,buttonOn,buttonDesc,buttonOff;
    ArrayAdapter<String> adapter,detectedAdapter;
    static HandleSeacrh handleSeacrh;
    BluetoothDevice bdDevice;
    BluetoothClass bdClass;
    ArrayList<BluetoothDevice> arrayListPairedBluetoothDevices;
    private ButtonClicked clicked;
    ListItemClickedonPaired listItemClickedonPaired;
    BluetoothAdapter bluetoothAdapter = null;
    ArrayList<BluetoothDevice> arrayListBluetoothDevices = null;
    ListItemClicked listItemClicked;
    @Override 
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        listViewDetected = (ListView) findViewById(R.id.listViewDetected);
        listViewPaired = (ListView) findViewById(R.id.listViewPaired);
        buttonSearch = (Button) findViewById(R.id.buttonSearch);
        buttonOn = (Button) findViewById(R.id.buttonOn);
        buttonDesc = (Button) findViewById(R.id.buttonDesc);
        buttonOff = (Button) findViewById(R.id.buttonOff); 
        arrayListpaired = new ArrayList<String>();
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        clicked = new ButtonClicked();
        handleSeacrh = new HandleSeacrh();
        arrayListPairedBluetoothDevices = new ArrayList<BluetoothDevice>();
        /*
         * the above declaration is just for getting the paired bluetooth devices;
         * this helps in the removing the bond between paired devices.
         */
        listItemClickedonPaired = new ListItemClickedonPaired();
        arrayListBluetoothDevices = new ArrayList<BluetoothDevice>();
        adapter= new ArrayAdapter<String>(BluetoothDemo.this, android.R.layout.simple_list_item_1, arrayListpaired);
        detectedAdapter = new ArrayAdapter<String>(BluetoothDemo.this, android.R.layout.simple_list_item_single_choice);
        listViewDetected.setAdapter(detectedAdapter);
        listItemClicked = new ListItemClicked();
        detectedAdapter.notifyDataSetChanged();
        listViewPaired.setAdapter(adapter);
    }
    @Override
    protected void onStart() {
        // TODO Auto-generated method stub
        super.onStart();
        getPairedDevices();
        buttonOn.setOnClickListener(clicked);
        buttonSearch.setOnClickListener(clicked);
        buttonDesc.setOnClickListener(clicked);
        buttonOff.setOnClickListener(clicked);
        listViewDetected.setOnItemClickListener(listItemClicked);
        listViewPaired.setOnItemClickListener(listItemClickedonPaired);
    }
    private void getPairedDevices() {
        Set<BluetoothDevice> pairedDevice = bluetoothAdapter.getBondedDevices();            
        if(pairedDevice.size()>0)
        {
            for(BluetoothDevice device : pairedDevice)
            {
                arrayListpaired.add(device.getName()+"\n"+device.getAddress());
                arrayListPairedBluetoothDevices.add(device);
            }
        }
        adapter.notifyDataSetChanged();
    }
    class ListItemClicked implements OnItemClickListener
    {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            // TODO Auto-generated method stub
            bdDevice = arrayListBluetoothDevices.get(position);
            //bdClass = arrayListBluetoothDevices.get(position);
            Log.i("Log", "The dvice : "+bdDevice.toString());
            /*
             * here below we can do pairing without calling the callthread(), we can directly call the
             * connect(). but for the safer side we must usethe threading object.
             */
            //callThread();
            //connect(bdDevice);
            Boolean isBonded = false;
            try {
                isBonded = createBond(bdDevice);
                if(isBonded)
                {
                    //arrayListpaired.add(bdDevice.getName()+"\n"+bdDevice.getAddress());
                    //adapter.notifyDataSetChanged();
                    getPairedDevices();
                    adapter.notifyDataSetChanged();
                }
            } catch (Exception e) {
                e.printStackTrace(); 
            }//connect(bdDevice);
            Log.i("Log", "The bond is created: "+isBonded);
        }       
    }
    class ListItemClickedonPaired implements OnItemClickListener
    {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position,long id) {
            bdDevice = arrayListPairedBluetoothDevices.get(position);
            try {
                Boolean removeBonding = removeBond(bdDevice);
                if(removeBonding)
                {
                    arrayListpaired.remove(position);
                    adapter.notifyDataSetChanged();
                }


                Log.i("Log", "Removed"+removeBonding);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    /*private void callThread() {
        new Thread(){
            public void run() {
                Boolean isBonded = false;
                try {
                    isBonded = createBond(bdDevice);
                    if(isBonded)
                    {
                        arrayListpaired.add(bdDevice.getName()+"\n"+bdDevice.getAddress());
                        adapter.notifyDataSetChanged();
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace(); 
                }//connect(bdDevice);
                Log.i("Log", "The bond is created: "+isBonded);
            }           
        }.start();
    }*/
    private Boolean connect(BluetoothDevice bdDevice) { 
        Boolean bool = false;
        try {
            Log.i("Log", "service method is called ");
            Class cl = Class.forName("android.bluetooth.BluetoothDevice");
            Class[] par = {};
            Method method = cl.getMethod("createBond", par);
            Object[] args = {};
            bool = (Boolean) method.invoke(bdDevice);//, args);// this invoke creates the detected devices paired.
            //Log.i("Log", "This is: "+bool.booleanValue());
            //Log.i("Log", "devicesss: "+bdDevice.getName());
        } catch (Exception e) {
            Log.i("Log", "Inside catch of serviceFromDevice Method");
            e.printStackTrace();
        }
        return bool.booleanValue();
    };


    public boolean removeBond(BluetoothDevice btDevice)  
    throws Exception  
    {  
        Class btClass = Class.forName("android.bluetooth.BluetoothDevice");
        Method removeBondMethod = btClass.getMethod("removeBond");  
        Boolean returnValue = (Boolean) removeBondMethod.invoke(btDevice);  
        return returnValue.booleanValue();  
    }


    public boolean createBond(BluetoothDevice btDevice)  
    throws Exception  
    { 
        Class class1 = Class.forName("android.bluetooth.BluetoothDevice");
        Method createBondMethod = class1.getMethod("createBond");  
        Boolean returnValue = (Boolean) createBondMethod.invoke(btDevice);  
        return returnValue.booleanValue();  
    }  


    class ButtonClicked implements OnClickListener
    {
        @Override
        public void onClick(View view) {
            switch (view.getId()) {
            case R.id.buttonOn:
                onBluetooth();
                break;
            case R.id.buttonSearch:
                arrayListBluetoothDevices.clear();
                startSearching();
                break;
            case R.id.buttonDesc:
                makeDiscoverable();
                break;
            case R.id.buttonOff:
                offBluetooth();
                break;
            default:
                break;
            }
        }
    }
    private BroadcastReceiver myReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Message msg = Message.obtain();
            String action = intent.getAction();
            if(BluetoothDevice.ACTION_FOUND.equals(action)){
                Toast.makeText(context, "ACTION_FOUND", Toast.LENGTH_SHORT).show();

                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                try
                {
                    //device.getClass().getMethod("setPairingConfirmation", boolean.class).invoke(device, true);
                    //device.getClass().getMethod("cancelPairingUserInput", boolean.class).invoke(device);
                }
                catch (Exception e) {
                    Log.i("Log", "Inside the exception: ");
                    e.printStackTrace();
                }

                if(arrayListBluetoothDevices.size()<1) // this checks if the size of bluetooth device is 0,then add the
                {                                           // device to the arraylist.
                    detectedAdapter.add(device.getName()+"\n"+device.getAddress());
                    arrayListBluetoothDevices.add(device);
                    detectedAdapter.notifyDataSetChanged();
                }
                else
                {
                    boolean flag = true;    // flag to indicate that particular device is already in the arlist or not
                    for(int i = 0; i<arrayListBluetoothDevices.size();i++)
                    {
                        if(device.getAddress().equals(arrayListBluetoothDevices.get(i).getAddress()))
                        {
                            flag = false;
                        }
                    }
                    if(flag == true)
                    {
                        detectedAdapter.add(device.getName()+"\n"+device.getAddress());
                        arrayListBluetoothDevices.add(device);
                        detectedAdapter.notifyDataSetChanged();
                    }
                }
            }           
        }
    };
    private void startSearching() {
        Log.i("Log", "in the start searching method");
        IntentFilter intentFilter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
        BluetoothDemo.this.registerReceiver(myReceiver, intentFilter);
        bluetoothAdapter.startDiscovery();
    }
    private void onBluetooth() {
        if(!bluetoothAdapter.isEnabled())
        {
            bluetoothAdapter.enable();
            Log.i("Log", "Bluetooth is Enabled");
        }
    }
    private void offBluetooth() {
        if(bluetoothAdapter.isEnabled())
        {
            bluetoothAdapter.disable();
        }
    }
    private void makeDiscoverable() {
        Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
        discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
        startActivity(discoverableIntent);
        Log.i("Log", "Discoverable ");
    }
    class HandleSeacrh extends Handler
    {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case 111:

                break;

            default:
                break;
            }
        }
    }
}

这里是 ma​​in.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <Button 
        android:id="@+id/buttonOn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="On"/>
    <Button 
        android:id="@+id/buttonDesc"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Make Discoverable"/>
   <Button 
       android:id="@+id/buttonSearch"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:text="Search"/>
   <Button 
       android:id="@+id/buttonOff"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:text="Bluetooth Off"/>

   <ListView 
       android:id="@+id/listViewPaired"
       android:layout_width="match_parent"
       android:layout_height="120dp">

   </ListView>

   <ListView 
       android:id="@+id/listViewDetected"
       android:layout_width="match_parent"
       android:layout_height="match_parent">

   </ListView>
</LinearLayout>

将此权限添加到您的清单文件。

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

希望这能消除您的所有疑虑。它在同样的情况下对我有帮助.. 由Narendra pal here on my question 回答

Answer 3

使用下面的 github 演示建立连接并从设备读取数据。 https://github.com/pires/obd-java-api