在我的蓝牙课程中遇到奇怪的 NPE，以前没有发生过

Question

使用 Android 的蓝牙聊天示例应用程序作为我的指南 http://developer.android.com /resources/samples/BluetoothChat/index.html，我尝试为我正在开发的应用程序创建自己的蓝牙功能。

昨晚我用两部Android手机进行了测试，出现了一些问题，但没有强制关闭。当我要求它连接时，它根本没有连接我的设备。我进去添加了几行日志，以确保程序遵循正确的路线。今天，当我在手机上重新安装并启动该应用程序时，在尝试打开蓝牙时遇到强制关闭错误，而昨晚我根本没有遇到这个问题。我更改的唯一代码是添加了 2-3 个日志命令。我检查了 logcat 并得到以下内容：

作为你可以看到，问题是由 NPE @ line 185 引起的。这是我的 BluetoothService 类的代码，我将在下面重新发布问题的具体区域。

package com.tagapp.android;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
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;

public class BluetoothService {

    private static final String TAG = "BluetoothService";
    private static final boolean D = true;
    private static final String NAME = "BluetoothTag";
    private static final UUID MY_UUID = 
        UUID.fromString("93845760-234e-11e0-ac64-0800200c9a66");

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

    public static final int STATE_NONE = 0;
    public static final int STATE_LISTEN = 1;
    public static final int STATE_CONNECTING = 2;
    public static final int STATE_CONNECTED = 3;

    public BluetoothService(Context context, Handler handler) {
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mState = STATE_NONE;
        mHandler = handler;
    }

    private synchronized void setState(int state) {
        if (D) Log.d(TAG, "setState() " + mState + " -> " + state);
        mState = state;
        mHandler.obtainMessage(BluetoothTransfer.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
    }

    public synchronized int getState() {
        return mState;
    }

    public synchronized void start() {
        if (D) Log.d(TAG, "start");

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

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

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

    public synchronized void connect(BluetoothDevice device) {
        if (D) Log.d(TAG, "connect to: " + device);
        if(mState == STATE_CONNECTING) {
            if(mConnectThread != null) {
                mConnectThread.cancel();
                mConnectThread = null;
            }
        }
        if(mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }
        mConnectThread = new ConnectThread(device);
        mConnectThread.start();
        setState(STATE_CONNECTING);
    }

    public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
        if (D) Log.d(TAG, "connected");

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

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

        if(mAcceptThread != null) {
            mAcceptThread.cancel();
            mAcceptThread = null;
        }
        mConnectedThread = new ConnectedThread(socket);
        mConnectedThread.start();
        Message msg = mHandler.obtainMessage(BluetoothTransfer.MESSAGE_DEVICE_NAME);
        Bundle bundle = new Bundle();
        bundle.putString(BluetoothTransfer.DEVICE_NAME, device.getName());
        msg.setData(bundle);
        mHandler.sendMessage(msg);
        setState(STATE_CONNECTED);
    }

    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;
        }
        setState(STATE_NONE);
    }

    public void write(byte[] out) {
        ConnectedThread ct;
        synchronized(this) {
            if(mState != STATE_CONNECTED) return;
            ct = mConnectedThread;
        }
        ct.write(out);
    }

    private void connectionFailed() {
        setState(STATE_LISTEN);
        Message msg = mHandler.obtainMessage(BluetoothTransfer.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(BluetoothTransfer.TOAST, "Unable to connect device");
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }

    private void connectionLost() {
        setState(STATE_LISTEN);
        Message msg = mHandler.obtainMessage(BluetoothTransfer.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(BluetoothTransfer.TOAST, "Device connection was lost");
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }

    private class AcceptThread extends Thread {
        private final BluetoothServerSocket mmServerSocket;

        public AcceptThread() {
            BluetoothServerSocket tmp = null;
            try {
                tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_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;
            while (mState != STATE_CONNECTED) {
                try {
                    socket = mmServerSocket.accept();
                }
                catch (IOException e) {
                    Log.e(TAG, "accept() failed", e);
                    break;
                }
                if(socket != null) {
                    synchronized (BluetoothService.this) {
                        switch(mState) {
                        case STATE_LISTEN :
                        case STATE_CONNECTING :
                            connected(socket, socket.getRemoteDevice());
                            break;
                        case STATE_NONE :
                        case STATE_CONNECTED :
                            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);
            }
        }
    }

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

        public ConnectThread(BluetoothDevice device) {
            mmDevice = device;
            BluetoothSocket tmp = null;
            try {
                tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
            }
            catch (IOException e) {
                Log.e(TAG, "create() failed", e);
            }
            mmSocket = tmp;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectThread");
            setName("ConnectThread");
            mAdapter.cancelDiscovery();
            try {
                mmSocket.connect();
            }
            catch (IOException e) {
                connectionFailed();
                try {
                    mmSocket.close();
                }
                catch (IOException e2) {
                    Log.e(TAG, "unable to close() socket during connection failure", e2);
                }
            BluetoothService.this.start();
            return;
            }
            synchronized (BluetoothService.this) {
                mConnectThread = null;
            }
            connected(mmSocket, mmDevice);
        }

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

    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;
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
            }
            catch (IOException e) {
                Log.e(TAG, "tempt sockets not created", e);
            }
            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectedThread");
            byte[] buffer = new byte[1024];
            int bytes;
            while (true) {
                try {
                    bytes = mmInStream.read(buffer);
                    mHandler.obtainMessage(BluetoothTransfer.CONTACT_RECEIVE, bytes, -1, buffer).sendToTarget();
                }
                catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    connectionLost();
                    break;
                }
            }
        }

        public void write(byte[] buffer) {
            try {
                mmOutStream.write(buffer);
                mHandler.obtainMessage(BluetoothTransfer.CONTACT_SEND, -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);
            }
        }
    }
}

导致NPE（AcceptThread）的行：

private class AcceptThread extends Thread {
    private final BluetoothServerSocket mmServerSocket;

    public AcceptThread() {
        BluetoothServerSocket tmp = null;
        try {
            tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_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;
        while (mState != STATE_CONNECTED) {
            try {
                socket = mmServerSocket.accept();//THIS LINE CAUSES NPE
            }
            catch (IOException e) {
                Log.e(TAG, "accept() failed", e);
                break;
            }

对象套接字应该初始化@ null，但应该尝试socket = mmServerSocket.accept（）;

这直接来自 Android 开发网站上提供的 Google 示例应用程序。我有两个问题：1，为什么这不起作用，2，为什么几个小时前它还工作得很好？

感谢您的帮助。

Answer 1

关于“奇怪的NPE”——一点也不奇怪。在这一行得到 NPE 的原因

socket = mmServerSocket.accept(); //THIS LINE CAUSES NPE

非常明显 - 变量 mmServerSocket 等于 NULL，这是在这行代码中得到 NPE 的唯一可能原因。 mmServerSocket 等于 NULL 的原因也很简单 - 查看类的构造函数：

public AcceptThread() {
    BluetoothServerSocket tmp = null;
    try {
        tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
    }
    catch (IOException e) {
        Log.e(TAG, "listen() failed", e);
    }
    mmServerSocket = tmp;
}

您正在调用抛出 IOException 的方法 listenUsingRfcommWithServiceRecord，您捕获了此异常，我们可以清楚地看到请参阅 logcat。接下来，tmp变量保持初始化为NULL，与mmServerSocket相同，这导致了上面提到的NPE。

listenUsingRfcommWithServiceRecord 抛出 IOException 的原因 - 因为蓝牙已关闭，正如您在问题中提到的那样。 Android 文档没有说明您的假设，即如果蓝牙关闭，此方法应自动打开蓝牙。我认为您应该在调用 listenUsingRfcommWithServiceRecord 之前手动检查蓝牙是否已关闭并手动打开。

您可以了解如何检查蓝牙是否打开/关闭以及如何将其打开 此处和此处